Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 193 insertions, 0 deletions

diff --git a/widget/nsPrimitiveHelpers.cpp b/widget/nsPrimitiveHelpers.cpp
new file mode 100644
index 0000000000..ea36f32d72
--- /dev/null
+++ b/widget/nsPrimitiveHelpers.cpp
@@ -0,0 +1,193 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+//
+// Part of the reason these routines are all in once place is so that as new
+// data flavors are added that are known to be one-byte or two-byte strings, or
+// even raw binary data, then we just have to go to one place to change how the
+// data moves into/out of the primitives and native line endings.
+//
+// If you add new flavors that have special consideration (binary data or
+// one-byte char* strings), please update all the helper classes in this file.
+//
+// For now, this is the assumption that we are making:
+//  - text/plain is always a char*
+//  - anything else is a char16_t*
+//
+
+#include "nsPrimitiveHelpers.h"
+
+#include "mozilla/UniquePtr.h"
+#include "nsComponentManagerUtils.h"
+#include "nsCOMPtr.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+#include "nsITransferable.h"
+#include "nsLinebreakConverter.h"
+#include "nsReadableUtils.h"
+
+//
+// CreatePrimitiveForData
+//
+// Given some data and the flavor it corresponds to, creates the appropriate
+// nsISupports* wrapper for passing across IDL boundaries. Right now, everything
+// creates a two-byte |nsISupportsString|, except for "text/plain" and native
+// platform HTML (CF_HTML on win32)
+//
+void nsPrimitiveHelpers ::CreatePrimitiveForData(const nsACString& aFlavor,
+                                                 const void* aDataBuff,
+                                                 uint32_t aDataLen,
+                                                 nsISupports** aPrimitive) {
+  if (!aPrimitive) return;
+
+  if (aFlavor.EqualsLiteral(kNativeHTMLMime) ||
+      aFlavor.EqualsLiteral(kRTFMime) ||
+      aFlavor.EqualsLiteral(kCustomTypesMime)) {
+    nsCOMPtr<nsISupportsCString> primitive =
+        do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID);
+    if (primitive) {
+      const char* start = reinterpret_cast<const char*>(aDataBuff);
+      primitive->SetData(Substring(start, start + aDataLen));
+      NS_ADDREF(*aPrimitive = primitive);
+    }
+  } else {
+    nsCOMPtr<nsISupportsString> primitive =
+        do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID);
+    if (primitive) {
+      if (aDataLen % 2) {
+        auto buffer = mozilla::MakeUnique<char[]>(aDataLen + 1);
+        if (!MOZ_LIKELY(buffer)) return;
+
+        memcpy(buffer.get(), aDataBuff, aDataLen);
+        buffer[aDataLen] = 0;
+        const char16_t* start = reinterpret_cast<const char16_t*>(buffer.get());
+        // recall that length takes length as characters, not bytes
+        primitive->SetData(Substring(start, start + (aDataLen + 1) / 2));
+      } else {
+        const char16_t* start = reinterpret_cast<const char16_t*>(aDataBuff);
+        // recall that length takes length as characters, not bytes
+        primitive->SetData(Substring(start, start + (aDataLen / 2)));
+      }
+      NS_ADDREF(*aPrimitive = primitive);
+    }
+  }
+
+}  // CreatePrimitiveForData
+
+//
+// CreatePrimitiveForCFHTML
+//
+// Platform specific CreatePrimitive, windows CF_HTML.
+//
+void nsPrimitiveHelpers ::CreatePrimitiveForCFHTML(const void* aDataBuff,
+                                                   uint32_t* aDataLen,
+                                                   nsISupports** aPrimitive) {
+  if (!aPrimitive) return;
+
+  nsCOMPtr<nsISupportsString> primitive =
+      do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID);
+  if (!primitive) return;
+
+  // We need to duplicate the input buffer, since the removal of linebreaks
+  // might reallocte it.
+  void* utf8 = moz_xmalloc(*aDataLen);
+  memcpy(utf8, aDataBuff, *aDataLen);
+  int32_t signedLen = static_cast<int32_t>(*aDataLen);
+  nsLinebreakHelpers::ConvertPlatformToDOMLinebreaks(true, &utf8, &signedLen);
+  *aDataLen = signedLen;
+
+  nsAutoString str(
+      NS_ConvertUTF8toUTF16(reinterpret_cast<const char*>(utf8), *aDataLen));
+  free(utf8);
+  *aDataLen = str.Length() * sizeof(char16_t);
+  primitive->SetData(str);
+  NS_ADDREF(*aPrimitive = primitive);
+}
+
+//
+// CreateDataFromPrimitive
+//
+// Given a nsISupports* primitive and the flavor it represents, creates a new
+// data buffer with the data in it. This data will be null terminated, but the
+// length parameter does not reflect that.
+//
+void nsPrimitiveHelpers::CreateDataFromPrimitive(const nsACString& aFlavor,
+                                                 nsISupports* aPrimitive,
+                                                 void** aDataBuff,
+                                                 uint32_t* aDataLen) {
+  if (!aDataBuff) return;
+
+  *aDataBuff = nullptr;
+  *aDataLen = 0;
+
+  if (aFlavor.EqualsLiteral(kCustomTypesMime)) {
+    nsCOMPtr<nsISupportsCString> plainText(do_QueryInterface(aPrimitive));
+    if (plainText) {
+      nsAutoCString data;
+      plainText->GetData(data);
+      *aDataBuff = ToNewCString(data);
+      *aDataLen = data.Length() * sizeof(char);
+    }
+  } else {
+    nsCOMPtr<nsISupportsString> doubleByteText(do_QueryInterface(aPrimitive));
+    if (doubleByteText) {
+      nsAutoString data;
+      doubleByteText->GetData(data);
+      *aDataBuff = ToNewUnicode(data);
+      *aDataLen = data.Length() * sizeof(char16_t);
+    }
+  }
+}
+
+//
+// ConvertPlatformToDOMLinebreaks
+//
+// Given some data, convert from the platform linebreaks into the LF expected by
+// the DOM. This will attempt to convert the data in place, but the buffer may
+// still need to be reallocated regardless (disposing the old buffer is taken
+// care of internally, see the note below).
+//
+// NOTE: this assumes that it can use 'free' to dispose of the old buffer.
+//
+nsresult nsLinebreakHelpers ::ConvertPlatformToDOMLinebreaks(
+    bool aIsSingleByteChars, void** ioData, int32_t* ioLengthInBytes) {
+  NS_ASSERTION(ioData && *ioData && ioLengthInBytes, "Bad Params");
+  if (!(ioData && *ioData && ioLengthInBytes)) return NS_ERROR_INVALID_ARG;
+
+  nsresult retVal = NS_OK;
+
+  // RTF and CF_HTML on Windows are transfered as single-byte characters.
+  if (aIsSingleByteChars) {
+    char* buffAsChars = reinterpret_cast<char*>(*ioData);
+    char* oldBuffer = buffAsChars;
+    retVal = nsLinebreakConverter::ConvertLineBreaksInSitu(
+        &buffAsChars, nsLinebreakConverter::eLinebreakAny,
+        nsLinebreakConverter::eLinebreakContent, *ioLengthInBytes,
+        ioLengthInBytes);
+    if (NS_SUCCEEDED(retVal)) {
+      if (buffAsChars != oldBuffer)  // check if buffer was reallocated
+        free(oldBuffer);
+      *ioData = buffAsChars;
+    }
+  } else {
+    char16_t* buffAsUnichar = reinterpret_cast<char16_t*>(*ioData);
+    char16_t* oldBuffer = buffAsUnichar;
+    int32_t newLengthInChars;
+    retVal = nsLinebreakConverter::ConvertUnicharLineBreaksInSitu(
+        &buffAsUnichar, nsLinebreakConverter::eLinebreakAny,
+        nsLinebreakConverter::eLinebreakContent,
+        *ioLengthInBytes / sizeof(char16_t), &newLengthInChars);
+    if (NS_SUCCEEDED(retVal)) {
+      if (buffAsUnichar != oldBuffer)  // check if buffer was reallocated
+        free(oldBuffer);
+      *ioData = buffAsUnichar;
+      *ioLengthInBytes = newLengthInChars * sizeof(char16_t);
+    }
+  }
+
+  return retVal;
+
+}  // ConvertPlatformToDOMLinebreaks