summaryrefslogtreecommitdiff
path: root/dom/events/DataTransfer.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'dom/events/DataTransfer.cpp')
-rw-r--r--dom/events/DataTransfer.cpp1565
1 files changed, 1565 insertions, 0 deletions
diff --git a/dom/events/DataTransfer.cpp b/dom/events/DataTransfer.cpp
new file mode 100644
index 0000000000..2c6ecdd56a
--- /dev/null
+++ b/dom/events/DataTransfer.cpp
@@ -0,0 +1,1565 @@
+/* -*- 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/ArrayUtils.h"
+#include "mozilla/BasicEvents.h"
+
+#include "DataTransfer.h"
+
+#include "nsIDOMDocument.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIScriptSecurityManager.h"
+#include "mozilla/dom/DOMStringList.h"
+#include "nsArray.h"
+#include "nsError.h"
+#include "nsIDragService.h"
+#include "nsIClipboard.h"
+#include "nsContentUtils.h"
+#include "nsIContent.h"
+#include "nsIBinaryInputStream.h"
+#include "nsIBinaryOutputStream.h"
+#include "nsIStorageStream.h"
+#include "nsStringStream.h"
+#include "nsCRT.h"
+#include "nsIScriptObjectPrincipal.h"
+#include "nsIScriptContext.h"
+#include "nsIDocument.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsVariant.h"
+#include "mozilla/dom/ContentChild.h"
+#include "mozilla/dom/DataTransferBinding.h"
+#include "mozilla/dom/DataTransferItemList.h"
+#include "mozilla/dom/Directory.h"
+#include "mozilla/dom/Element.h"
+#include "mozilla/dom/FileList.h"
+#include "mozilla/dom/BindingUtils.h"
+#include "mozilla/dom/OSFileSystem.h"
+#include "mozilla/dom/Promise.h"
+#include "nsNetUtil.h"
+
+namespace mozilla {
+namespace dom {
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(DataTransfer)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DataTransfer)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mParent)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mItems)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mDragTarget)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK(mDragImage)
+ NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(DataTransfer)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mParent)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mItems)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDragTarget)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mDragImage)
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(DataTransfer)
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(DataTransfer)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(DataTransfer)
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DataTransfer)
+ NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
+ NS_INTERFACE_MAP_ENTRY(mozilla::dom::DataTransfer)
+ NS_INTERFACE_MAP_ENTRY(nsIDOMDataTransfer)
+ NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIDOMDataTransfer)
+NS_INTERFACE_MAP_END
+
+// the size of the array
+const char DataTransfer::sEffects[8][9] = {
+ "none", "copy", "move", "copyMove", "link", "copyLink", "linkMove", "all"
+};
+
+// Used for custom clipboard types.
+enum CustomClipboardTypeId {
+ eCustomClipboardTypeId_None,
+ eCustomClipboardTypeId_String
+};
+
+DataTransfer::DataTransfer(nsISupports* aParent, EventMessage aEventMessage,
+ bool aIsExternal, int32_t aClipboardType)
+ : mParent(aParent)
+ , mDropEffect(nsIDragService::DRAGDROP_ACTION_NONE)
+ , mEffectAllowed(nsIDragService::DRAGDROP_ACTION_UNINITIALIZED)
+ , mEventMessage(aEventMessage)
+ , mCursorState(false)
+ , mReadOnly(true)
+ , mIsExternal(aIsExternal)
+ , mUserCancelled(false)
+ , mIsCrossDomainSubFrameDrop(false)
+ , mClipboardType(aClipboardType)
+ , mDragImageX(0)
+ , mDragImageY(0)
+{
+ mItems = new DataTransferItemList(this, aIsExternal);
+ // For these events, we want to be able to add data to the data transfer, so
+ // clear the readonly state. Otherwise, the data is already present. For
+ // external usage, cache the data from the native clipboard or drag.
+ if (aEventMessage == eCut ||
+ aEventMessage == eCopy ||
+ aEventMessage == eDragStart) {
+ mReadOnly = false;
+ } else if (mIsExternal) {
+ if (aEventMessage == ePaste) {
+ CacheExternalClipboardFormats();
+ } else if (aEventMessage >= eDragDropEventFirst &&
+ aEventMessage <= eDragDropEventLast) {
+ CacheExternalDragFormats();
+ }
+ }
+}
+
+DataTransfer::DataTransfer(nsISupports* aParent,
+ EventMessage aEventMessage,
+ const uint32_t aEffectAllowed,
+ bool aCursorState,
+ bool aIsExternal,
+ bool aUserCancelled,
+ bool aIsCrossDomainSubFrameDrop,
+ int32_t aClipboardType,
+ DataTransferItemList* aItems,
+ Element* aDragImage,
+ uint32_t aDragImageX,
+ uint32_t aDragImageY)
+ : mParent(aParent)
+ , mDropEffect(nsIDragService::DRAGDROP_ACTION_NONE)
+ , mEffectAllowed(aEffectAllowed)
+ , mEventMessage(aEventMessage)
+ , mCursorState(aCursorState)
+ , mReadOnly(true)
+ , mIsExternal(aIsExternal)
+ , mUserCancelled(aUserCancelled)
+ , mIsCrossDomainSubFrameDrop(aIsCrossDomainSubFrameDrop)
+ , mClipboardType(aClipboardType)
+ , mDragImage(aDragImage)
+ , mDragImageX(aDragImageX)
+ , mDragImageY(aDragImageY)
+{
+ MOZ_ASSERT(mParent);
+ MOZ_ASSERT(aItems);
+
+ // We clone the items array after everything else, so that it has a valid
+ // mParent value
+ mItems = aItems->Clone(this);
+ // The items are copied from aItems into mItems. There is no need to copy
+ // the actual data in the items as the data transfer will be read only. The
+ // dragstart event is the only time when items are
+ // modifiable, but those events should have been using the first constructor
+ // above.
+ NS_ASSERTION(aEventMessage != eDragStart,
+ "invalid event type for DataTransfer constructor");
+}
+
+DataTransfer::~DataTransfer()
+{}
+
+// static
+already_AddRefed<DataTransfer>
+DataTransfer::Constructor(const GlobalObject& aGlobal,
+ const nsAString& aEventType, bool aIsExternal,
+ ErrorResult& aRv)
+{
+ nsAutoCString onEventType("on");
+ AppendUTF16toUTF8(aEventType, onEventType);
+ nsCOMPtr<nsIAtom> eventTypeAtom = NS_Atomize(onEventType);
+ if (!eventTypeAtom) {
+ aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
+ return nullptr;
+ }
+
+ EventMessage eventMessage = nsContentUtils::GetEventMessage(eventTypeAtom);
+ RefPtr<DataTransfer> transfer = new DataTransfer(aGlobal.GetAsSupports(),
+ eventMessage, aIsExternal,
+ -1);
+ return transfer.forget();
+}
+
+JSObject*
+DataTransfer::WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto)
+{
+ return DataTransferBinding::Wrap(aCx, this, aGivenProto);
+}
+
+NS_IMETHODIMP
+DataTransfer::GetDropEffect(nsAString& aDropEffect)
+{
+ nsString dropEffect;
+ GetDropEffect(dropEffect);
+ aDropEffect = dropEffect;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetDropEffect(const nsAString& aDropEffect)
+{
+ // the drop effect can only be 'none', 'copy', 'move' or 'link'.
+ for (uint32_t e = 0; e <= nsIDragService::DRAGDROP_ACTION_LINK; e++) {
+ if (aDropEffect.EqualsASCII(sEffects[e])) {
+ // don't allow copyMove
+ if (e != (nsIDragService::DRAGDROP_ACTION_COPY |
+ nsIDragService::DRAGDROP_ACTION_MOVE)) {
+ mDropEffect = e;
+ }
+ break;
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::GetEffectAllowed(nsAString& aEffectAllowed)
+{
+ nsString effectAllowed;
+ GetEffectAllowed(effectAllowed);
+ aEffectAllowed = effectAllowed;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetEffectAllowed(const nsAString& aEffectAllowed)
+{
+ if (aEffectAllowed.EqualsLiteral("uninitialized")) {
+ mEffectAllowed = nsIDragService::DRAGDROP_ACTION_UNINITIALIZED;
+ return NS_OK;
+ }
+
+ static_assert(nsIDragService::DRAGDROP_ACTION_NONE == 0,
+ "DRAGDROP_ACTION_NONE constant is wrong");
+ static_assert(nsIDragService::DRAGDROP_ACTION_COPY == 1,
+ "DRAGDROP_ACTION_COPY constant is wrong");
+ static_assert(nsIDragService::DRAGDROP_ACTION_MOVE == 2,
+ "DRAGDROP_ACTION_MOVE constant is wrong");
+ static_assert(nsIDragService::DRAGDROP_ACTION_LINK == 4,
+ "DRAGDROP_ACTION_LINK constant is wrong");
+
+ for (uint32_t e = 0; e < ArrayLength(sEffects); e++) {
+ if (aEffectAllowed.EqualsASCII(sEffects[e])) {
+ mEffectAllowed = e;
+ break;
+ }
+ }
+
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::GetDropEffectInt(uint32_t* aDropEffect)
+{
+ *aDropEffect = mDropEffect;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetDropEffectInt(uint32_t aDropEffect)
+{
+ mDropEffect = aDropEffect;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::GetEffectAllowedInt(uint32_t* aEffectAllowed)
+{
+ *aEffectAllowed = mEffectAllowed;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetEffectAllowedInt(uint32_t aEffectAllowed)
+{
+ mEffectAllowed = aEffectAllowed;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::GetMozUserCancelled(bool* aUserCancelled)
+{
+ *aUserCancelled = MozUserCancelled();
+ return NS_OK;
+}
+
+already_AddRefed<FileList>
+DataTransfer::GetFiles(nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ return mItems->Files(&aSubjectPrincipal);
+}
+
+NS_IMETHODIMP
+DataTransfer::GetFiles(nsIDOMFileList** aFileList)
+{
+ if (!aFileList) {
+ return NS_ERROR_FAILURE;
+ }
+
+ // The XPCOM interface is only avaliable to system code, and thus we can
+ // assume the system principal. This is consistent with the previous behavour
+ // of this function, which also assumed the system principal.
+ //
+ // This code is also called from C++ code, which expects it to have a System
+ // Principal, and thus the SubjectPrincipal cannot be used.
+ RefPtr<FileList> files = mItems->Files(nsContentUtils::GetSystemPrincipal());
+
+ files.forget(aFileList);
+ return NS_OK;
+}
+
+void
+DataTransfer::GetTypes(nsTArray<nsString>& aTypes,
+ nsIPrincipal& aSubjectPrincipal) const
+{
+ // When called from bindings, aTypes will be empty, but since we might have
+ // Gecko-internal callers too, clear it to be safe.
+ aTypes.Clear();
+
+ const nsTArray<RefPtr<DataTransferItem>>* items = mItems->MozItemsAt(0);
+ if (NS_WARN_IF(!items)) {
+ return;
+ }
+
+ for (uint32_t i = 0; i < items->Length(); i++) {
+ DataTransferItem* item = items->ElementAt(i);
+ MOZ_ASSERT(item);
+
+ if (item->ChromeOnly() && !nsContentUtils::IsSystemPrincipal(&aSubjectPrincipal)) {
+ continue;
+ }
+
+ // NOTE: The reason why we get the internal type here is because we want
+ // kFileMime to appear in the types list for backwards compatibility
+ // reasons.
+ nsAutoString type;
+ item->GetInternalType(type);
+ if (item->Kind() == DataTransferItem::KIND_STRING || type.EqualsASCII(kFileMime)) {
+ // If the entry has kind KIND_STRING, we want to add it to the list.
+ aTypes.AppendElement(type);
+ }
+ }
+
+ for (uint32_t i = 0; i < mItems->Length(); ++i) {
+ bool found = false;
+ DataTransferItem* item = mItems->IndexedGetter(i, found);
+ MOZ_ASSERT(found);
+ if (item->Kind() != DataTransferItem::KIND_FILE) {
+ continue;
+ }
+ aTypes.AppendElement(NS_LITERAL_STRING("Files"));
+ break;
+ }
+}
+
+void
+DataTransfer::GetData(const nsAString& aFormat, nsAString& aData,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ // return an empty string if data for the format was not found
+ aData.Truncate();
+
+ nsCOMPtr<nsIVariant> data;
+ nsresult rv =
+ GetDataAtInternal(aFormat, 0, &aSubjectPrincipal,
+ getter_AddRefs(data));
+ if (NS_FAILED(rv)) {
+ if (rv != NS_ERROR_DOM_INDEX_SIZE_ERR) {
+ aRv.Throw(rv);
+ }
+ return;
+ }
+
+ if (data) {
+ nsAutoString stringdata;
+ data->GetAsAString(stringdata);
+
+ // for the URL type, parse out the first URI from the list. The URIs are
+ // separated by newlines
+ nsAutoString lowercaseFormat;
+ nsContentUtils::ASCIIToLower(aFormat, lowercaseFormat);
+
+ if (lowercaseFormat.EqualsLiteral("url")) {
+ int32_t lastidx = 0, idx;
+ int32_t length = stringdata.Length();
+ while (lastidx < length) {
+ idx = stringdata.FindChar('\n', lastidx);
+ // lines beginning with # are comments
+ if (stringdata[lastidx] == '#') {
+ if (idx == -1) {
+ break;
+ }
+ }
+ else {
+ if (idx == -1) {
+ aData.Assign(Substring(stringdata, lastidx));
+ } else {
+ aData.Assign(Substring(stringdata, lastidx, idx - lastidx));
+ }
+ aData = nsContentUtils::TrimWhitespace<nsCRT::IsAsciiSpace>(aData,
+ true);
+ return;
+ }
+ lastidx = idx + 1;
+ }
+ }
+ else {
+ aData = stringdata;
+ }
+ }
+}
+
+void
+DataTransfer::SetData(const nsAString& aFormat, const nsAString& aData,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ RefPtr<nsVariantCC> variant = new nsVariantCC();
+ variant->SetAsAString(aData);
+
+ aRv = SetDataAtInternal(aFormat, variant, 0, &aSubjectPrincipal);
+}
+
+void
+DataTransfer::ClearData(const Optional<nsAString>& aFormat,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ if (mReadOnly) {
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+ return;
+ }
+
+ if (MozItemCount() == 0) {
+ return;
+ }
+
+ if (aFormat.WasPassed()) {
+ MozClearDataAtHelper(aFormat.Value(), 0, aSubjectPrincipal, aRv);
+ } else {
+ MozClearDataAtHelper(EmptyString(), 0, aSubjectPrincipal, aRv);
+ }
+}
+
+NS_IMETHODIMP
+DataTransfer::GetMozItemCount(uint32_t* aCount)
+{
+ *aCount = MozItemCount();
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::GetMozCursor(nsAString& aCursorState)
+{
+ nsString cursor;
+ GetMozCursor(cursor);
+ aCursorState = cursor;
+ return NS_OK;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetMozCursor(const nsAString& aCursorState)
+{
+ // Lock the cursor to an arrow during the drag.
+ mCursorState = aCursorState.EqualsLiteral("default");
+
+ return NS_OK;
+}
+
+already_AddRefed<nsINode>
+DataTransfer::GetMozSourceNode()
+{
+ nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+ if (!dragSession) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIDOMNode> sourceNode;
+ dragSession->GetSourceNode(getter_AddRefs(sourceNode));
+ nsCOMPtr<nsINode> node = do_QueryInterface(sourceNode);
+ if (node && !nsContentUtils::LegacyIsCallerNativeCode()
+ && !nsContentUtils::CanCallerAccess(node)) {
+ return nullptr;
+ }
+
+ return node.forget();
+}
+
+NS_IMETHODIMP
+DataTransfer::GetMozSourceNode(nsIDOMNode** aSourceNode)
+{
+ nsCOMPtr<nsINode> sourceNode = GetMozSourceNode();
+ if (!sourceNode) {
+ *aSourceNode = nullptr;
+ return NS_OK;
+ }
+
+ return CallQueryInterface(sourceNode, aSourceNode);
+}
+
+already_AddRefed<DOMStringList>
+DataTransfer::MozTypesAt(uint32_t aIndex, ErrorResult& aRv) const
+{
+ // Only the first item is valid for clipboard events
+ if (aIndex > 0 &&
+ (mEventMessage == eCut || mEventMessage == eCopy ||
+ mEventMessage == ePaste)) {
+ aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+ return nullptr;
+ }
+
+ RefPtr<DOMStringList> types = new DOMStringList();
+ if (aIndex < MozItemCount()) {
+ // note that you can retrieve the types regardless of their principal
+ const nsTArray<RefPtr<DataTransferItem>>& items = *mItems->MozItemsAt(aIndex);
+
+ bool addFile = false;
+ for (uint32_t i = 0; i < items.Length(); i++) {
+ if (items[i]->ChromeOnly() && !nsContentUtils::LegacyIsCallerChromeOrNativeCode()) {
+ continue;
+ }
+
+ // NOTE: The reason why we get the internal type here is because we want
+ // kFileMime to appear in the types list for backwards compatibility
+ // reasons.
+ nsAutoString type;
+ items[i]->GetInternalType(type);
+ if (NS_WARN_IF(!types->Add(type))) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ if (items[i]->Kind() == DataTransferItem::KIND_FILE) {
+ addFile = true;
+ }
+ }
+
+ if (addFile) {
+ types->Add(NS_LITERAL_STRING("Files"));
+ }
+ }
+
+ return types.forget();
+}
+
+NS_IMETHODIMP
+DataTransfer::MozTypesAt(uint32_t aIndex, nsISupports** aTypes)
+{
+ ErrorResult rv;
+ RefPtr<DOMStringList> types = MozTypesAt(aIndex, rv);
+ types.forget(aTypes);
+ return rv.StealNSResult();
+}
+
+nsresult
+DataTransfer::GetDataAtNoSecurityCheck(const nsAString& aFormat,
+ uint32_t aIndex,
+ nsIVariant** aData)
+{
+ return GetDataAtInternal(aFormat, aIndex,
+ nsContentUtils::GetSystemPrincipal(), aData);
+}
+
+nsresult
+DataTransfer::GetDataAtInternal(const nsAString& aFormat, uint32_t aIndex,
+ nsIPrincipal* aSubjectPrincipal,
+ nsIVariant** aData)
+{
+ *aData = nullptr;
+
+ if (aFormat.IsEmpty()) {
+ return NS_OK;
+ }
+
+ if (aIndex >= MozItemCount()) {
+ return NS_ERROR_DOM_INDEX_SIZE_ERR;
+ }
+
+ // Only the first item is valid for clipboard events
+ if (aIndex > 0 &&
+ (mEventMessage == eCut || mEventMessage == eCopy ||
+ mEventMessage == ePaste)) {
+ return NS_ERROR_DOM_INDEX_SIZE_ERR;
+ }
+
+ nsAutoString format;
+ GetRealFormat(aFormat, format);
+
+ MOZ_ASSERT(aSubjectPrincipal);
+
+ RefPtr<DataTransferItem> item = mItems->MozItemByTypeAt(format, aIndex);
+ if (!item) {
+ // The index exists but there's no data for the specified format, in this
+ // case we just return undefined
+ return NS_OK;
+ }
+
+ // If we have chrome only content, and we aren't chrome, don't allow access
+ if (!nsContentUtils::IsSystemPrincipal(aSubjectPrincipal) && item->ChromeOnly()) {
+ return NS_OK;
+ }
+
+ // DataTransferItem::Data() handles the principal checks
+ ErrorResult result;
+ nsCOMPtr<nsIVariant> data = item->Data(aSubjectPrincipal, result);
+ if (NS_WARN_IF(!data || result.Failed())) {
+ return result.StealNSResult();
+ }
+
+ data.forget(aData);
+ return NS_OK;
+}
+
+void
+DataTransfer::MozGetDataAt(JSContext* aCx, const nsAString& aFormat,
+ uint32_t aIndex,
+ JS::MutableHandle<JS::Value> aRetval,
+ nsIPrincipal& aSubjectPrincipal,
+ mozilla::ErrorResult& aRv)
+{
+ nsCOMPtr<nsIVariant> data;
+ aRv = GetDataAtInternal(aFormat, aIndex, &aSubjectPrincipal,
+ getter_AddRefs(data));
+ if (aRv.Failed()) {
+ return;
+ }
+
+ if (!data) {
+ aRetval.setNull();
+ return;
+ }
+
+ JS::Rooted<JS::Value> result(aCx);
+ if (!VariantToJsval(aCx, data, aRetval)) {
+ aRv = NS_ERROR_FAILURE;
+ return;
+ }
+}
+
+/* static */ bool
+DataTransfer::PrincipalMaySetData(const nsAString& aType,
+ nsIVariant* aData,
+ nsIPrincipal* aPrincipal)
+{
+ if (!nsContentUtils::IsSystemPrincipal(aPrincipal)) {
+ DataTransferItem::eKind kind = DataTransferItem::KindFromData(aData);
+ if (kind == DataTransferItem::KIND_OTHER) {
+ NS_WARNING("Disallowing adding non string/file types to DataTransfer");
+ return false;
+ }
+
+ if (aType.EqualsASCII(kFileMime) ||
+ aType.EqualsASCII(kFilePromiseMime)) {
+ NS_WARNING("Disallowing adding x-moz-file or x-moz-file-promize types to DataTransfer");
+ return false;
+ }
+ }
+ return true;
+}
+
+void
+DataTransfer::TypesListMayHaveChanged()
+{
+ DataTransferBinding::ClearCachedTypesValue(this);
+}
+
+nsresult
+DataTransfer::SetDataAtInternal(const nsAString& aFormat, nsIVariant* aData,
+ uint32_t aIndex,
+ nsIPrincipal* aSubjectPrincipal)
+{
+ if (aFormat.IsEmpty()) {
+ return NS_OK;
+ }
+
+ if (mReadOnly) {
+ return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
+ }
+
+ // Specifying an index less than the current length will replace an existing
+ // item. Specifying an index equal to the current length will add a new item.
+ if (aIndex > MozItemCount()) {
+ return NS_ERROR_DOM_INDEX_SIZE_ERR;
+ }
+
+ // Only the first item is valid for clipboard events
+ if (aIndex > 0 &&
+ (mEventMessage == eCut || mEventMessage == eCopy ||
+ mEventMessage == ePaste)) {
+ return NS_ERROR_DOM_INDEX_SIZE_ERR;
+ }
+
+ // Don't allow the custom type to be assigned.
+ if (aFormat.EqualsLiteral(kCustomTypesMime)) {
+ return NS_ERROR_TYPE_ERR;
+ }
+
+ if (!PrincipalMaySetData(aFormat, aData, aSubjectPrincipal)) {
+ return NS_ERROR_DOM_SECURITY_ERR;
+ }
+
+ return SetDataWithPrincipal(aFormat, aData, aIndex, aSubjectPrincipal);
+}
+
+void
+DataTransfer::MozSetDataAt(JSContext* aCx, const nsAString& aFormat,
+ JS::Handle<JS::Value> aData, uint32_t aIndex,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ nsCOMPtr<nsIVariant> data;
+ aRv = nsContentUtils::XPConnect()->JSValToVariant(aCx, aData,
+ getter_AddRefs(data));
+ if (!aRv.Failed()) {
+ aRv = SetDataAtInternal(aFormat, data, aIndex, &aSubjectPrincipal);
+ }
+}
+
+void
+DataTransfer::MozClearDataAt(const nsAString& aFormat, uint32_t aIndex,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ if (mReadOnly) {
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+ return;
+ }
+
+ if (aIndex >= MozItemCount()) {
+ aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+ return;
+ }
+
+ // Only the first item is valid for clipboard events
+ if (aIndex > 0 &&
+ (mEventMessage == eCut || mEventMessage == eCopy ||
+ mEventMessage == ePaste)) {
+ aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
+ return;
+ }
+
+ MozClearDataAtHelper(aFormat, aIndex, aSubjectPrincipal, aRv);
+
+ // If we just cleared the 0-th index, and there are still more than 1 indexes
+ // remaining, MozClearDataAt should cause the 1st index to become the 0th
+ // index. This should _only_ happen when the MozClearDataAt function is
+ // explicitly called by script, as this behavior is inconsistent with spec.
+ // (however, so is the MozClearDataAt API)
+
+ if (aIndex == 0 && mItems->MozItemCount() > 1 &&
+ mItems->MozItemsAt(0)->Length() == 0) {
+ mItems->PopIndexZero();
+ }
+}
+
+void
+DataTransfer::MozClearDataAtHelper(const nsAString& aFormat, uint32_t aIndex,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ MOZ_ASSERT(!mReadOnly);
+ MOZ_ASSERT(aIndex < MozItemCount());
+ MOZ_ASSERT(aIndex == 0 ||
+ (mEventMessage != eCut && mEventMessage != eCopy &&
+ mEventMessage != ePaste));
+
+ nsAutoString format;
+ GetRealFormat(aFormat, format);
+
+ mItems->MozRemoveByTypeAt(format, aIndex, aSubjectPrincipal, aRv);
+}
+
+void
+DataTransfer::SetDragImage(Element& aImage, int32_t aX, int32_t aY,
+ ErrorResult& aRv)
+{
+ if (mReadOnly) {
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+ return;
+ }
+
+ mDragImage = &aImage;
+ mDragImageX = aX;
+ mDragImageY = aY;
+}
+
+NS_IMETHODIMP
+DataTransfer::SetDragImage(nsIDOMElement* aImage, int32_t aX, int32_t aY)
+{
+ ErrorResult rv;
+ nsCOMPtr<Element> image = do_QueryInterface(aImage);
+ if (image) {
+ SetDragImage(*image, aX, aY, rv);
+ }
+ return rv.StealNSResult();
+}
+
+already_AddRefed<Promise>
+DataTransfer::GetFilesAndDirectories(nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ nsCOMPtr<nsINode> parentNode = do_QueryInterface(mParent);
+ if (!parentNode) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ nsCOMPtr<nsIGlobalObject> global = parentNode->OwnerDoc()->GetScopeObject();
+ MOZ_ASSERT(global);
+ if (!global) {
+ aRv.Throw(NS_ERROR_FAILURE);
+ return nullptr;
+ }
+
+ RefPtr<Promise> p = Promise::Create(global, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ RefPtr<FileList> files = mItems->Files(&aSubjectPrincipal);
+ if (NS_WARN_IF(!files)) {
+ return nullptr;
+ }
+
+ Sequence<RefPtr<File>> filesSeq;
+ files->ToSequence(filesSeq, aRv);
+ if (NS_WARN_IF(aRv.Failed())) {
+ return nullptr;
+ }
+
+ p->MaybeResolve(filesSeq);
+
+ return p.forget();
+}
+
+already_AddRefed<Promise>
+DataTransfer::GetFiles(bool aRecursiveFlag,
+ nsIPrincipal& aSubjectPrincipal,
+ ErrorResult& aRv)
+{
+ // Currently we don't support directories.
+ return GetFilesAndDirectories(aSubjectPrincipal, aRv);
+}
+
+void
+DataTransfer::AddElement(Element& aElement, ErrorResult& aRv)
+{
+ if (mReadOnly) {
+ aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
+ return;
+ }
+
+ mDragTarget = &aElement;
+}
+
+NS_IMETHODIMP
+DataTransfer::AddElement(nsIDOMElement* aElement)
+{
+ NS_ENSURE_TRUE(aElement, NS_ERROR_NULL_POINTER);
+
+ nsCOMPtr<Element> element = do_QueryInterface(aElement);
+ NS_ENSURE_TRUE(element, NS_ERROR_INVALID_ARG);
+
+ ErrorResult rv;
+ AddElement(*element, rv);
+ return rv.StealNSResult();
+}
+
+nsresult
+DataTransfer::Clone(nsISupports* aParent, EventMessage aEventMessage,
+ bool aUserCancelled, bool aIsCrossDomainSubFrameDrop,
+ DataTransfer** aNewDataTransfer)
+{
+ RefPtr<DataTransfer> newDataTransfer =
+ new DataTransfer(aParent, aEventMessage, mEffectAllowed, mCursorState,
+ mIsExternal, aUserCancelled, aIsCrossDomainSubFrameDrop,
+ mClipboardType, mItems, mDragImage, mDragImageX,
+ mDragImageY);
+
+ newDataTransfer.forget(aNewDataTransfer);
+ return NS_OK;
+}
+
+already_AddRefed<nsIArray>
+DataTransfer::GetTransferables(nsIDOMNode* aDragTarget)
+{
+ MOZ_ASSERT(aDragTarget);
+
+ nsCOMPtr<nsINode> dragNode = do_QueryInterface(aDragTarget);
+ if (!dragNode) {
+ return nullptr;
+ }
+
+ nsIDocument* doc = dragNode->GetComposedDoc();
+ if (!doc) {
+ return nullptr;
+ }
+
+ return GetTransferables(doc->GetLoadContext());
+}
+
+already_AddRefed<nsIArray>
+DataTransfer::GetTransferables(nsILoadContext* aLoadContext)
+{
+ nsCOMPtr<nsIMutableArray> transArray = nsArray::Create();
+ if (!transArray) {
+ return nullptr;
+ }
+
+ uint32_t count = MozItemCount();
+ for (uint32_t i = 0; i < count; i++) {
+ nsCOMPtr<nsITransferable> transferable = GetTransferable(i, aLoadContext);
+ if (transferable) {
+ transArray->AppendElement(transferable, /*weak =*/ false);
+ }
+ }
+
+ return transArray.forget();
+}
+
+already_AddRefed<nsITransferable>
+DataTransfer::GetTransferable(uint32_t aIndex, nsILoadContext* aLoadContext)
+{
+ if (aIndex >= MozItemCount()) {
+ return nullptr;
+ }
+
+ const nsTArray<RefPtr<DataTransferItem>>& item = *mItems->MozItemsAt(aIndex);
+ uint32_t count = item.Length();
+ if (!count) {
+ return nullptr;
+ }
+
+ nsCOMPtr<nsITransferable> transferable =
+ do_CreateInstance("@mozilla.org/widget/transferable;1");
+ if (!transferable) {
+ return nullptr;
+ }
+ transferable->Init(aLoadContext);
+
+ nsCOMPtr<nsIStorageStream> storageStream;
+ nsCOMPtr<nsIBinaryOutputStream> stream;
+
+ bool added = false;
+ bool handlingCustomFormats = true;
+
+ // When writing the custom data, we need to ensure that there is sufficient
+ // space for a (uint32_t) data ending type, and the null byte character at
+ // the end of the nsCString. We claim that space upfront and store it in
+ // baseLength. This value will be set to zero if a write error occurs
+ // indicating that the data and length are no longer valid.
+ const uint32_t baseLength = sizeof(uint32_t) + 1;
+ uint32_t totalCustomLength = baseLength;
+
+ const char* knownFormats[] = {
+ kTextMime, kHTMLMime, kNativeHTMLMime, kRTFMime,
+ kURLMime, kURLDataMime, kURLDescriptionMime, kURLPrivateMime,
+ kPNGImageMime, kJPEGImageMime, kGIFImageMime, kNativeImageMime,
+ kFileMime, kFilePromiseMime, kFilePromiseURLMime,
+ kFilePromiseDestFilename, kFilePromiseDirectoryMime,
+ kMozTextInternal, kHTMLContext, kHTMLInfo };
+
+ /*
+ * Two passes are made here to iterate over all of the types. First, look for
+ * any types that are not in the list of known types. For this pass,
+ * handlingCustomFormats will be true. Data that corresponds to unknown types
+ * will be pulled out and inserted into a single type (kCustomTypesMime) by
+ * writing the data into a stream.
+ *
+ * The second pass will iterate over the formats looking for known types.
+ * These are added as is. The unknown types are all then inserted as a single
+ * type (kCustomTypesMime) in the same position of the first custom type. This
+ * model is used to maintain the format order as best as possible.
+ *
+ * The format of the kCustomTypesMime type is one or more of the following
+ * stored sequentially:
+ * <32-bit> type (only none or string is supported)
+ * <32-bit> length of format
+ * <wide string> format
+ * <32-bit> length of data
+ * <wide string> data
+ * A type of eCustomClipboardTypeId_None ends the list, without any following
+ * data.
+ */
+ do {
+ for (uint32_t f = 0; f < count; f++) {
+ RefPtr<DataTransferItem> formatitem = item[f];
+ nsCOMPtr<nsIVariant> variant = formatitem->DataNoSecurityCheck();
+ if (!variant) { // skip empty items
+ continue;
+ }
+
+ nsAutoString type;
+ formatitem->GetInternalType(type);
+
+ // If the data is of one of the well-known formats, use it directly.
+ bool isCustomFormat = true;
+ for (uint32_t f = 0; f < ArrayLength(knownFormats); f++) {
+ if (type.EqualsASCII(knownFormats[f])) {
+ isCustomFormat = false;
+ break;
+ }
+ }
+
+ uint32_t lengthInBytes;
+ nsCOMPtr<nsISupports> convertedData;
+
+ if (handlingCustomFormats) {
+ if (!ConvertFromVariant(variant, getter_AddRefs(convertedData),
+ &lengthInBytes)) {
+ continue;
+ }
+
+ // When handling custom types, add the data to the stream if this is a
+ // custom type. If totalCustomLength is 0, then a write error occurred
+ // on a previous item, so ignore any others.
+ if (isCustomFormat && totalCustomLength > 0) {
+ // If it isn't a string, just ignore it. The dataTransfer is cached in
+ // the drag sesion during drag-and-drop, so non-strings will be
+ // available when dragging locally.
+ nsCOMPtr<nsISupportsString> str(do_QueryInterface(convertedData));
+ if (str) {
+ nsAutoString data;
+ str->GetData(data);
+
+ if (!stream) {
+ // Create a storage stream to write to.
+ NS_NewStorageStream(1024, UINT32_MAX, getter_AddRefs(storageStream));
+
+ nsCOMPtr<nsIOutputStream> outputStream;
+ storageStream->GetOutputStream(0, getter_AddRefs(outputStream));
+
+ stream = do_CreateInstance("@mozilla.org/binaryoutputstream;1");
+ stream->SetOutputStream(outputStream);
+ }
+
+ CheckedInt<uint32_t> formatLength =
+ CheckedInt<uint32_t>(type.Length()) * sizeof(nsString::char_type);
+
+ // The total size of the stream is the format length, the data
+ // length, two integers to hold the lengths and one integer for
+ // the string flag. Guard against large data by ignoring any that
+ // don't fit.
+ CheckedInt<uint32_t> newSize = formatLength + totalCustomLength +
+ lengthInBytes + (sizeof(uint32_t) * 3);
+ if (newSize.isValid()) {
+ // If a write error occurs, set totalCustomLength to 0 so that
+ // further processing gets ignored.
+ nsresult rv = stream->Write32(eCustomClipboardTypeId_String);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ totalCustomLength = 0;
+ continue;
+ }
+ rv = stream->Write32(formatLength.value());
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ totalCustomLength = 0;
+ continue;
+ }
+ rv = stream->WriteBytes((const char *)type.get(), formatLength.value());
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ totalCustomLength = 0;
+ continue;
+ }
+ rv = stream->Write32(lengthInBytes);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ totalCustomLength = 0;
+ continue;
+ }
+ rv = stream->WriteBytes((const char *)data.get(), lengthInBytes);
+ if (NS_WARN_IF(NS_FAILED(rv))) {
+ totalCustomLength = 0;
+ continue;
+ }
+
+ totalCustomLength = newSize.value();
+ }
+ }
+ }
+ } else if (isCustomFormat && stream) {
+ // This is the second pass of the loop (handlingCustomFormats is false).
+ // When encountering the first custom format, append all of the stream
+ // at this position. If totalCustomLength is 0 indicating a write error
+ // occurred, or no data has been added to it, don't output anything,
+ if (totalCustomLength > baseLength) {
+ // Write out an end of data terminator.
+ nsresult rv = stream->Write32(eCustomClipboardTypeId_None);
+ if (NS_SUCCEEDED(rv)) {
+ nsCOMPtr<nsIInputStream> inputStream;
+ storageStream->NewInputStream(0, getter_AddRefs(inputStream));
+
+ RefPtr<nsStringBuffer> stringBuffer =
+ nsStringBuffer::Alloc(totalCustomLength);
+
+ // Subtract off the null terminator when reading.
+ totalCustomLength--;
+
+ // Read the data from the stream and add a null-terminator as
+ // ToString needs it.
+ uint32_t amountRead;
+ rv = inputStream->Read(static_cast<char*>(stringBuffer->Data()),
+ totalCustomLength, &amountRead);
+ if (NS_SUCCEEDED(rv)) {
+ static_cast<char*>(stringBuffer->Data())[amountRead] = 0;
+
+ nsCString str;
+ stringBuffer->ToString(totalCustomLength, str);
+ nsCOMPtr<nsISupportsCString>
+ strSupports(do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
+ strSupports->SetData(str);
+
+ nsresult rv = transferable->SetTransferData(kCustomTypesMime,
+ strSupports,
+ totalCustomLength);
+ if (NS_FAILED(rv)) {
+ return nullptr;
+ }
+
+ added = true;
+ }
+ }
+ }
+
+ // Clear the stream so it doesn't get used again.
+ stream = nullptr;
+ } else {
+ // This is the second pass of the loop and a known type is encountered.
+ // Add it as is.
+ if (!ConvertFromVariant(variant, getter_AddRefs(convertedData),
+ &lengthInBytes)) {
+ continue;
+ }
+
+ // The underlying drag code uses text/unicode, so use that instead of
+ // text/plain
+ const char* format;
+ NS_ConvertUTF16toUTF8 utf8format(type);
+ if (utf8format.EqualsLiteral(kTextMime)) {
+ format = kUnicodeMime;
+ } else {
+ format = utf8format.get();
+ }
+
+ // If a converter is set for a format, set the converter for the
+ // transferable and don't add the item
+ nsCOMPtr<nsIFormatConverter> converter =
+ do_QueryInterface(convertedData);
+ if (converter) {
+ transferable->AddDataFlavor(format);
+ transferable->SetConverter(converter);
+ continue;
+ }
+
+ nsresult rv = transferable->SetTransferData(format, convertedData,
+ lengthInBytes);
+ if (NS_FAILED(rv)) {
+ return nullptr;
+ }
+
+ added = true;
+ }
+ }
+
+ handlingCustomFormats = !handlingCustomFormats;
+ } while (!handlingCustomFormats);
+
+ // only return the transferable if data was successfully added to it
+ if (added) {
+ return transferable.forget();
+ }
+
+ return nullptr;
+}
+
+bool
+DataTransfer::ConvertFromVariant(nsIVariant* aVariant,
+ nsISupports** aSupports,
+ uint32_t* aLength) const
+{
+ *aSupports = nullptr;
+ *aLength = 0;
+
+ uint16_t type;
+ aVariant->GetDataType(&type);
+ if (type == nsIDataType::VTYPE_INTERFACE ||
+ type == nsIDataType::VTYPE_INTERFACE_IS) {
+ nsCOMPtr<nsISupports> data;
+ if (NS_FAILED(aVariant->GetAsISupports(getter_AddRefs(data)))) {
+ return false;
+ }
+
+ nsCOMPtr<nsIFlavorDataProvider> fdp = do_QueryInterface(data);
+ if (fdp) {
+ // for flavour data providers, use kFlavorHasDataProvider (which has the
+ // value 0) as the length.
+ fdp.forget(aSupports);
+ *aLength = nsITransferable::kFlavorHasDataProvider;
+ }
+ else {
+ // wrap the item in an nsISupportsInterfacePointer
+ nsCOMPtr<nsISupportsInterfacePointer> ptrSupports =
+ do_CreateInstance(NS_SUPPORTS_INTERFACE_POINTER_CONTRACTID);
+ if (!ptrSupports) {
+ return false;
+ }
+
+ ptrSupports->SetData(data);
+ ptrSupports.forget(aSupports);
+
+ *aLength = sizeof(nsISupportsInterfacePointer *);
+ }
+
+ return true;
+ }
+
+ char16_t* chrs;
+ uint32_t len = 0;
+ nsresult rv = aVariant->GetAsWStringWithSize(&len, &chrs);
+ if (NS_FAILED(rv)) {
+ return false;
+ }
+
+ nsAutoString str;
+ str.Adopt(chrs, len);
+
+ nsCOMPtr<nsISupportsString>
+ strSupports(do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID));
+ if (!strSupports) {
+ return false;
+ }
+
+ strSupports->SetData(str);
+
+ strSupports.forget(aSupports);
+
+ // each character is two bytes
+ *aLength = str.Length() << 1;
+
+ return true;
+}
+
+void
+DataTransfer::ClearAll()
+{
+ mItems->ClearAllItems();
+}
+
+uint32_t
+DataTransfer::MozItemCount() const
+{
+ return mItems->MozItemCount();
+}
+
+nsresult
+DataTransfer::SetDataWithPrincipal(const nsAString& aFormat,
+ nsIVariant* aData,
+ uint32_t aIndex,
+ nsIPrincipal* aPrincipal)
+{
+ nsAutoString format;
+ GetRealFormat(aFormat, format);
+
+ ErrorResult rv;
+ RefPtr<DataTransferItem> item =
+ mItems->SetDataWithPrincipal(format, aData, aIndex, aPrincipal,
+ /* aInsertOnly = */ false,
+ /* aHidden= */ false,
+ rv);
+ return rv.StealNSResult();
+}
+
+void
+DataTransfer::SetDataWithPrincipalFromOtherProcess(const nsAString& aFormat,
+ nsIVariant* aData,
+ uint32_t aIndex,
+ nsIPrincipal* aPrincipal,
+ bool aHidden)
+{
+ if (aFormat.EqualsLiteral(kCustomTypesMime)) {
+ FillInExternalCustomTypes(aData, aIndex, aPrincipal);
+ } else {
+ nsAutoString format;
+ GetRealFormat(aFormat, format);
+
+ ErrorResult rv;
+ RefPtr<DataTransferItem> item =
+ mItems->SetDataWithPrincipal(format, aData, aIndex, aPrincipal,
+ /* aInsertOnly = */ false, aHidden, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ rv.SuppressException();
+ }
+ }
+}
+
+void
+DataTransfer::GetRealFormat(const nsAString& aInFormat,
+ nsAString& aOutFormat) const
+{
+ // treat text/unicode as equivalent to text/plain
+ nsAutoString lowercaseFormat;
+ nsContentUtils::ASCIIToLower(aInFormat, lowercaseFormat);
+ if (lowercaseFormat.EqualsLiteral("text") ||
+ lowercaseFormat.EqualsLiteral("text/unicode")) {
+ aOutFormat.AssignLiteral("text/plain");
+ return;
+ }
+
+ if (lowercaseFormat.EqualsLiteral("url")) {
+ aOutFormat.AssignLiteral("text/uri-list");
+ return;
+ }
+
+ aOutFormat.Assign(lowercaseFormat);
+}
+
+nsresult
+DataTransfer::CacheExternalData(const char* aFormat, uint32_t aIndex,
+ nsIPrincipal* aPrincipal, bool aHidden)
+{
+ ErrorResult rv;
+ RefPtr<DataTransferItem> item;
+
+ if (strcmp(aFormat, kUnicodeMime) == 0) {
+ item = mItems->SetDataWithPrincipal(NS_LITERAL_STRING("text/plain"), nullptr,
+ aIndex, aPrincipal, false, aHidden, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
+ return NS_OK;
+ }
+
+ if (strcmp(aFormat, kURLDataMime) == 0) {
+ item = mItems->SetDataWithPrincipal(NS_LITERAL_STRING("text/uri-list"), nullptr,
+ aIndex, aPrincipal, false, aHidden, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
+ return NS_OK;
+ }
+
+ nsAutoString format;
+ GetRealFormat(NS_ConvertUTF8toUTF16(aFormat), format);
+ item = mItems->SetDataWithPrincipal(format, nullptr, aIndex,
+ aPrincipal, false, aHidden, rv);
+ if (NS_WARN_IF(rv.Failed())) {
+ return rv.StealNSResult();
+ }
+ return NS_OK;
+}
+
+void
+DataTransfer::CacheExternalDragFormats()
+{
+ // Called during the constructor to cache the formats available from an
+ // external drag. The data associated with each format will be set to null.
+ // This data will instead only be retrieved in FillInExternalDragData when
+ // asked for, as it may be time consuming for the source application to
+ // generate it.
+
+ nsCOMPtr<nsIDragSession> dragSession = nsContentUtils::GetDragSession();
+ if (!dragSession) {
+ return;
+ }
+
+ // make sure that the system principal is used for external drags
+ nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+ nsCOMPtr<nsIPrincipal> sysPrincipal;
+ ssm->GetSystemPrincipal(getter_AddRefs(sysPrincipal));
+
+ // there isn't a way to get a list of the formats that might be available on
+ // all platforms, so just check for the types that can actually be imported
+ // XXXndeakin there are some other formats but those are platform specific.
+ // NOTE: kFileMime must have index 0
+ const char* formats[] = { kFileMime, kHTMLMime, kURLMime, kURLDataMime,
+ kUnicodeMime, kPNGImageMime };
+
+ uint32_t count;
+ dragSession->GetNumDropItems(&count);
+ for (uint32_t c = 0; c < count; c++) {
+ bool hasFileData = false;
+ dragSession->IsDataFlavorSupported(kFileMime, &hasFileData);
+
+ // First, check for the special format that holds custom types.
+ bool supported;
+ dragSession->IsDataFlavorSupported(kCustomTypesMime, &supported);
+ if (supported) {
+ FillInExternalCustomTypes(c, sysPrincipal);
+ }
+
+ for (uint32_t f = 0; f < ArrayLength(formats); f++) {
+ // IsDataFlavorSupported doesn't take an index as an argument and just
+ // checks if any of the items support a particular flavor, even though
+ // the GetData method does take an index. Here, we just assume that
+ // every item being dragged has the same set of flavors.
+ bool supported;
+ dragSession->IsDataFlavorSupported(formats[f], &supported);
+ // if the format is supported, add an item to the array with null as
+ // the data. When retrieved, GetRealData will read the data.
+ if (supported) {
+ CacheExternalData(formats[f], c, sysPrincipal, /* hidden = */ f && hasFileData);
+ }
+ }
+ }
+}
+
+void
+DataTransfer::CacheExternalClipboardFormats()
+{
+ NS_ASSERTION(mEventMessage == ePaste,
+ "caching clipboard data for invalid event");
+
+ // Called during the constructor for paste events to cache the formats
+ // available on the clipboard. As with CacheExternalDragFormats, the
+ // data will only be retrieved when needed.
+
+ nsCOMPtr<nsIClipboard> clipboard =
+ do_GetService("@mozilla.org/widget/clipboard;1");
+ if (!clipboard || mClipboardType < 0) {
+ return;
+ }
+
+ nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
+ nsCOMPtr<nsIPrincipal> sysPrincipal;
+ ssm->GetSystemPrincipal(getter_AddRefs(sysPrincipal));
+
+ // Check if the clipboard has any files
+ bool hasFileData = false;
+ const char *fileMime[] = { kFileMime };
+ clipboard->HasDataMatchingFlavors(fileMime, 1, mClipboardType, &hasFileData);
+
+ // We will be ignoring any application/x-moz-file files found in the paste
+ // datatransfer within e10s, as they will fail to be sent over IPC. Because of
+ // that, we will unset hasFileData, whether or not it would have been set.
+ // (bug 1308007)
+ if (XRE_IsContentProcess()) {
+ hasFileData = false;
+ }
+
+ // there isn't a way to get a list of the formats that might be available on
+ // all platforms, so just check for the types that can actually be imported.
+ // NOTE: kCustomTypesMime must have index 0, kFileMime index 1
+ const char* formats[] = { kCustomTypesMime, kFileMime, kHTMLMime, kRTFMime,
+ kURLMime, kURLDataMime, kUnicodeMime, kPNGImageMime };
+
+ for (uint32_t f = 0; f < mozilla::ArrayLength(formats); ++f) {
+ // check each format one at a time
+ bool supported;
+ clipboard->HasDataMatchingFlavors(&(formats[f]), 1, mClipboardType,
+ &supported);
+ // if the format is supported, add an item to the array with null as
+ // the data. When retrieved, GetRealData will read the data.
+ if (supported) {
+ if (f == 0) {
+ FillInExternalCustomTypes(0, sysPrincipal);
+ } else {
+ // In non-e10s we support pasting files from explorer.exe.
+ // Unfortunately, we fail to send that data over IPC in e10s, so we
+ // don't want to add the item to the DataTransfer and end up producing a
+ // null `application/x-moz-file`. (bug 1308007)
+ if (XRE_IsContentProcess() && f == 1) {
+ continue;
+ }
+
+ // If we aren't the file data, and we have file data, we want to be hidden
+ CacheExternalData(formats[f], 0, sysPrincipal, /* hidden = */ f != 1 && hasFileData);
+ }
+ }
+ }
+}
+
+void
+DataTransfer::FillAllExternalData()
+{
+ if (mIsExternal) {
+ for (uint32_t i = 0; i < MozItemCount(); ++i) {
+ const nsTArray<RefPtr<DataTransferItem>>& items = *mItems->MozItemsAt(i);
+ for (uint32_t j = 0; j < items.Length(); ++j) {
+ MOZ_ASSERT(items[j]->Index() == i);
+
+ items[j]->FillInExternalData();
+ }
+ }
+ }
+}
+
+void
+DataTransfer::FillInExternalCustomTypes(uint32_t aIndex,
+ nsIPrincipal* aPrincipal)
+{
+ RefPtr<DataTransferItem> item = new DataTransferItem(this,
+ NS_LITERAL_STRING(kCustomTypesMime),
+ DataTransferItem::KIND_STRING);
+ item->SetIndex(aIndex);
+
+ nsCOMPtr<nsIVariant> variant = item->DataNoSecurityCheck();
+ if (!variant) {
+ return;
+ }
+
+ FillInExternalCustomTypes(variant, aIndex, aPrincipal);
+}
+
+void
+DataTransfer::FillInExternalCustomTypes(nsIVariant* aData, uint32_t aIndex,
+ nsIPrincipal* aPrincipal)
+{
+ char* chrs;
+ uint32_t len = 0;
+ nsresult rv = aData->GetAsStringWithSize(&len, &chrs);
+ if (NS_FAILED(rv)) {
+ return;
+ }
+
+ nsAutoCString str;
+ str.Adopt(chrs, len);
+
+ nsCOMPtr<nsIInputStream> stringStream;
+ NS_NewCStringInputStream(getter_AddRefs(stringStream), str);
+
+ nsCOMPtr<nsIBinaryInputStream> stream =
+ do_CreateInstance("@mozilla.org/binaryinputstream;1");
+ if (!stream) {
+ return;
+ }
+
+ rv = stream->SetInputStream(stringStream);
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ uint32_t type;
+ do {
+ rv = stream->Read32(&type);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ if (type == eCustomClipboardTypeId_String) {
+ uint32_t formatLength;
+ rv = stream->Read32(&formatLength);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ char* formatBytes;
+ rv = stream->ReadBytes(formatLength, &formatBytes);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ nsAutoString format;
+ format.Adopt(reinterpret_cast<char16_t*>(formatBytes),
+ formatLength / sizeof(char16_t));
+
+ uint32_t dataLength;
+ rv = stream->Read32(&dataLength);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ char* dataBytes;
+ rv = stream->ReadBytes(dataLength, &dataBytes);
+ NS_ENSURE_SUCCESS_VOID(rv);
+ nsAutoString data;
+ data.Adopt(reinterpret_cast<char16_t*>(dataBytes),
+ dataLength / sizeof(char16_t));
+
+ RefPtr<nsVariantCC> variant = new nsVariantCC();
+ rv = variant->SetAsAString(data);
+ NS_ENSURE_SUCCESS_VOID(rv);
+
+ SetDataWithPrincipal(format, variant, aIndex, aPrincipal);
+ }
+ } while (type != eCustomClipboardTypeId_None);
+}
+
+} // namespace dom
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.26.2) at 2024-11-10 22:59:33 +0000