Page MenuHomeFreeBSD
Files F159663797

D22184.id64135.diff
No OneTemporary
Actions

D22184.id64135.diff
View Options

Index: www/qt5-webengine/Makefile
===================================================================
--- www/qt5-webengine/Makefile
+++ www/qt5-webengine/Makefile
@@ -110,6 +110,14 @@
CPLUS_INCLUDE_PATH=${LOCALBASE}/include \
${CONFIGURE_ENV}
+.include <bsd.port.pre.mk>
+
+.if ${ARCH:Mmips*} || ${ARCH:Mpowerpc*} || ${ARCH} == sparc64
+PLIST_SUB+= BE="" LE="@comment "
+.else
+PLIST_SUB+= BE="@comment " LE=""
+.endif
+
post-extract:
# Install FreeBSD's freebsd.pri file.
${CP} ${FILESDIR}/freebsd.pri ${WRKSRC}/src/core/config/freebsd.pri
@@ -121,6 +129,12 @@
@${CP} ${FILESDIR}/audio_manager_openbsd.* \
${WRKSRC}/src/3rdparty/chromium/media/audio/openbsd
+.if ${ARCH:Mmips*} || ${ARCH:Mpowerpc*} || ${ARCH} == sparc64
+post-patch:
+ @${REINPLACE_CMD} -e 's/icudtl.dat/icudtb.dat/' \
+ ${WRKSRC}/src/core/core_module.pro
+.endif
+
pre-configure:
# Link in ${PYTHON_CMD} to ${CONFIGURE_WRKSRC}/bin -- the scripts hardcode 'python'
# in too many places to reasonably patch. So just link in ${PYTHON_CMD} to work around
@@ -132,4 +146,4 @@
# Rerun syncqt.pl -- otherwise the resulting package misses some forwarding headers.
cd ${WRKSRC} && ${QT_BINDIR}/syncqt.pl -version ${QT5_VERSION}
-.include <bsd.port.mk>
+.include <bsd.port.post.mk>
Index: www/qt5-webengine/files/patch-mkspecs_features_functions.prf
===================================================================
--- www/qt5-webengine/files/patch-mkspecs_features_functions.prf
+++ www/qt5-webengine/files/patch-mkspecs_features_functions.prf
@@ -1,7 +1,7 @@
Include the freebsd.pri file provided by the port, to pass FreeBSD specific
settings to gn.
---- mkspecs/features/functions.prf.orig 2019-01-16 22:42:58 UTC
+--- mkspecs/features/functions.prf.orig 2019-05-24 09:01:39 UTC
+++ mkspecs/features/functions.prf
@@ -82,6 +82,7 @@ defineReplace(gnArgs) {
linux: include($$QTWEBENGINE_ROOT/src/core/config/linux.pri)
@@ -11,7 +11,15 @@
isEmpty(gn_args): error(No gn_args found please make sure you have valid configuration.)
return($$gn_args)
}
-@@ -101,6 +102,7 @@ defineReplace(gnOS) {
+@@ -94,6 +95,7 @@ defineReplace(gnArch) {
+ contains(qtArch, "arm64"): return(arm64)
+ contains(qtArch, "mips"): return(mipsel)
+ contains(qtArch, "mips64"): return(mips64el)
++ contains(qtArch, "power64"): return(ppc64)
+ return(unknown)
+ }
+
+@@ -101,6 +103,7 @@ defineReplace(gnOS) {
macos: return(mac)
win32: return(win)
linux: return(linux)
Index: www/qt5-webengine/files/patch-mkspecs_features_platform.prf
===================================================================
--- www/qt5-webengine/files/patch-mkspecs_features_platform.prf
+++ www/qt5-webengine/files/patch-mkspecs_features_platform.prf
@@ -1,4 +1,4 @@
---- mkspecs/features/platform.prf.orig 2018-11-27 04:10:38 UTC
+--- mkspecs/features/platform.prf.orig 2019-05-24 09:01:39 UTC
+++ mkspecs/features/platform.prf
@@ -11,7 +11,7 @@ defineTest(isQtMinimum) {
@@ -9,3 +9,11 @@
if(!gcc:!clang)|intel_icc {
skipBuild("Qt WebEngine on Linux requires clang or GCC.")
return(false)
+@@ -84,6 +84,7 @@ defineTest(isArchSupported) {
+ contains(QT_ARCH, "arm")|contains(QT_ARCH, "arm64"): return(true)
+ contains(QT_ARCH, "mips"): return(true)
+ # contains(QT_ARCH, "mips64"): return(true)
++ contains(QT_ARCH, "power64"): return(true)
+
+ skipBuild("QtWebEngine can only be built for x86, x86-64, ARM, Aarch64, and MIPSel architectures.")
+ return(false)
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_allocator_partition__allocator_partition__alloc.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_allocator_partition__allocator_partition__alloc.cc
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/base/allocator/partition_allocator/partition_alloc.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/allocator/partition_allocator/partition_alloc.cc
+@@ -440,7 +440,7 @@ static size_t PartitionPurgePage(internal::PartitionPa
+ #endif
+ }
+ // Terminate the freelist chain.
+- *entry_ptr = nullptr;
++ *entry_ptr = internal::PartitionFreelistEntry::Transform(nullptr);
+ // The freelist head is stored unmasked.
+ page->freelist_head =
+ internal::PartitionFreelistEntry::Transform(page->freelist_head);
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc
@@ -1,5 +1,5 @@
---- src/3rdparty/chromium/base/i18n/icu_util.cc.orig 2018-11-13 18:25:11 UTC
-+++ src/3rdparty/chromium/base/i18n/icu_util.cc
+--- src/3rdparty/chromium/base/i18n/icu_util.cc.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/base/i18n/icu_util.cc 2019-10-27 22:58:57.501541000 +0100
@@ -20,7 +20,7 @@
#include "build/build_config.h"
#include "third_party/icu/source/common/unicode/putil.h"
@@ -9,7 +9,19 @@
#include "third_party/icu/source/i18n/unicode/timezone.h"
#endif
-@@ -320,7 +320,7 @@ bool InitializeICU() {
+@@ -75,7 +75,11 @@
+ // No need to change the filename in multiple places (gyp files, windows
+ // build pkg configurations, etc). 'l' stands for Little Endian.
+ // This variable is exported through the header file.
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ const char kIcuDataFileName[] = "icudtl.dat";
++#else
++const char kIcuDataFileName[] = "icudtb.dat";
++#endif
+ #if defined(OS_ANDROID)
+ const char kAndroidAssetsIcuDataFileName[] = "assets/icudtl.dat";
+ #endif
+@@ -320,7 +324,7 @@
// TODO(jungshik): Some callers do not care about tz at all. If necessary,
// add a boolean argument to this function to init'd the default tz only
// when requested.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_memory_shared__memory__mapping__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_memory_shared__memory__mapping__unittest.cc
@@ -0,0 +1,39 @@
+--- src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc
+@@ -12,6 +12,7 @@
+ #include "base/containers/span.h"
+ #include "base/memory/read_only_shared_memory_region.h"
+ #include "testing/gtest/include/gtest/gtest.h"
++#include "base/sys_byteorder.h"
+
+ namespace base {
+
+@@ -69,8 +70,8 @@ TEST_F(SharedMemoryMappingTest, SpanWithAutoDeducedEle
+
+ for (size_t i = 0; i < write_span.size(); ++i)
+ write_span[i] = i + 1;
+- EXPECT_EQ(0x04030201u, read_span[0]);
+- EXPECT_EQ(0x08070605u, read_span[1]);
++ EXPECT_EQ(HostToNet32(0x01020304u), read_span[0]);
++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]);
+ }
+
+ TEST_F(SharedMemoryMappingTest, SpanWithExplicitElementCount) {
+@@ -95,13 +96,13 @@ TEST_F(SharedMemoryMappingTest, SpanWithExplicitElemen
+
+ for (size_t i = 0; i < write_span.size(); ++i)
+ write_span[i] = i + 1;
+- EXPECT_EQ(0x04030201u, read_span[0]);
+- EXPECT_EQ(0x08070605u, read_span[1]);
+- EXPECT_EQ(0x04030201u, read_span_2[0]);
++ EXPECT_EQ(HostToNet32(0x01020304u), read_span[0]);
++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]);
++ EXPECT_EQ(HostToNet32(0x01020304u), read_span_2[0]);
+
+ std::fill(write_span_2.begin(), write_span_2.end(), 0);
+ EXPECT_EQ(0u, read_span[0]);
+- EXPECT_EQ(0x08070605u, read_span[1]);
++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]);
+ EXPECT_EQ(0u, read_span_2[0]);
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_metrics_bucket__ranges__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_metrics_bucket__ranges__unittest.cc
@@ -0,0 +1,32 @@
+--- src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc
+@@ -7,6 +7,7 @@
+ #include <stdint.h>
+
+ #include "testing/gtest/include/gtest/gtest.h"
++#include "base/sys_byteorder.h"
+
+ namespace base {
+ namespace {
+@@ -64,13 +65,21 @@ TEST(BucketRangesTest, Checksum) {
+ ranges.set_range(2, 2);
+
+ ranges.ResetChecksum();
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ EXPECT_EQ(289217253u, ranges.checksum());
++#else
++ EXPECT_EQ(2767231596u, ranges.checksum());
++#endif
+
+ ranges.set_range(2, 3);
+ EXPECT_FALSE(ranges.HasValidChecksum());
+
+ ranges.ResetChecksum();
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ EXPECT_EQ(2843835776u, ranges.checksum());
++#else
++ EXPECT_EQ(3556223738u, ranges.checksum());
++#endif
+ EXPECT_TRUE(ranges.HasValidChecksum());
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_pickle.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_pickle.cc
@@ -0,0 +1,16 @@
+--- src/3rdparty/chromium/base/pickle.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/pickle.cc
+@@ -82,7 +82,12 @@ inline const char* PickleIterator::GetReadPointerAndAd
+ }
+
+ bool PickleIterator::ReadBool(bool* result) {
+- return ReadBuiltinType(result);
++ int int_result;
++ if (ReadBuiltinType(&int_result)) {
++ *result = static_cast<bool>(int_result);
++ return true;
++ } else
++ return false;
+ }
+
+ bool PickleIterator::ReadInt(int* result) {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_sha1.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_sha1.cc
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/base/sha1.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/sha1.cc
+@@ -110,8 +110,10 @@ void SecureHashAlgorithm::Final() {
+ Pad();
+ Process();
+
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ for (auto& t : H)
+ t = ByteSwap(t);
++#endif
+ }
+
+ void SecureHashAlgorithm::Update(const void* data, size_t nbytes) {
+@@ -157,8 +159,10 @@ void SecureHashAlgorithm::Process() {
+ //
+ // W and M are in a union, so no need to memcpy.
+ // memcpy(W, M, sizeof(M));
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ for (t = 0; t < 16; ++t)
+ W[t] = ByteSwap(W[t]);
++#endif
+
+ // b.
+ for (t = 16; t < 80; ++t)
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_strings_string__number__conversions__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_strings_string__number__conversions__unittest.cc
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/base/strings/string_number_conversions_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/strings/string_number_conversions_unittest.cc
+@@ -829,12 +829,21 @@ TEST(StringNumberConversionsTest, DoubleToString) {
+ }
+
+ // The following two values were seen in crashes in the wild.
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'};
++#else
++ const char input_bytes[8] = {'\x42', '\x73', '\x6d', '\xee', 0, 0, 0, 0};
++#endif
+ double input = 0;
+ memcpy(&input, input_bytes, base::size(input_bytes));
+ EXPECT_EQ("1335179083776", NumberToString(input));
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ const char input_bytes2[8] =
+ {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'};
++#else
++ const char input_bytes2[8] =
++ {'\x42', '\x73', '\x6c', '\xda', '\xa0', 0, 0, 0};
++#endif
+ input = 0;
+ memcpy(&input, input_bytes2, base::size(input_bytes2));
+ EXPECT_EQ("1334890332160", NumberToString(input));
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc
@@ -27,12 +27,14 @@
int SysInfo::NumberOfProcessors() {
return g_lazy_number_of_processors.Get().value();
}
-@@ -225,6 +225,8 @@ std::string SysInfo::OperatingSystemArchitecture() {
+@@ -225,7 +225,9 @@ std::string SysInfo::OperatingSystemArchitecture() {
arch = "x86";
} else if (arch == "amd64") {
arch = "x86_64";
+- } else if (std::string(info.sysname) == "AIX") {
+ } else if (arch == "arm64") {
+ arch = "aarch64";
- } else if (std::string(info.sysname) == "AIX") {
++ } else if (arch == "powerpc" || arch == "powerpc64") {
arch = "ppc64";
}
+ return arch;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_base_third__party_dmg__fp_dtoa.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_base_third__party_dmg__fp_dtoa.cc
@@ -0,0 +1,14 @@
+--- src/3rdparty/chromium/base/third_party/dmg_fp/dtoa.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/base/third_party/dmg_fp/dtoa.cc
+@@ -186,7 +186,11 @@
+ * used for input more than STRTOD_DIGLIM digits long (default 40).
+ */
+
++#ifdef __BIG_ENDIAN__
++#define IEEE_MC68k
++#else
+ #define IEEE_8087
++#endif
+ #define NO_HEX_FP
+
+ #ifndef Long
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_build_download__nacl__toolchains.py
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_build_download__nacl__toolchains.py
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/build/download_nacl_toolchains.py.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/build/download_nacl_toolchains.py
+@@ -11,6 +11,10 @@ import sys
+
+
+ def Main(args):
++ # If `disable_nacl=1` is in GYP_DEFINES, exit
++ if 'disable_nacl=1' in os.environ.get('GYP_DEFINES', ''):
++ return 0
++
+ script_dir = os.path.dirname(os.path.abspath(__file__))
+ src_dir = os.path.dirname(script_dir)
+ nacl_dir = os.path.join(src_dir, 'native_client')
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn
@@ -1,6 +1,21 @@
---- src/3rdparty/chromium/build/toolchain/linux/BUILD.gn.orig 2018-11-13 18:25:11 UTC
-+++ src/3rdparty/chromium/build/toolchain/linux/BUILD.gn
-@@ -14,7 +14,6 @@ clang_toolchain("clang_arm") {
+--- src/3rdparty/chromium/build/toolchain/linux/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/build/toolchain/linux/BUILD.gn 2019-10-29 02:47:24.026830000 +0100
+@@ -5,6 +5,14 @@
+ import("//build/config/sysroot.gni")
+ import("//build/toolchain/gcc_toolchain.gni")
+
++clang_toolchain("clang_ppc64") {
++ enable_linker_map = true
++ toolchain_args = {
++ current_cpu = "ppc64"
++ current_os = "linux"
++ }
++}
++
+ clang_toolchain("clang_arm") {
+ toolprefix = "arm-linux-gnueabihf-"
+ toolchain_args = {
+@@ -14,7 +22,6 @@
}
clang_toolchain("clang_arm64") {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_util__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_util__unittest.cc
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/components/safe_browsing/db/util_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/components/safe_browsing/db/util_unittest.cc
+@@ -12,6 +12,12 @@
+ #include "testing/gtest/include/gtest/gtest.h"
+ #include "url/gurl.h"
+
++#if defined(OS_WIN)
++#include <winsock2.h>
++#elif defined(OS_POSIX)
++#include <arpa/inet.h>
++#endif
++
+ namespace safe_browsing {
+
+ TEST(SafeBrowsingDbUtilTest, UrlToFullHashes) {
+@@ -83,7 +89,7 @@ TEST(SafeBrowsingDbUtilTest, StringToSBFullHashAndSBFu
+ // 31 chars plus the last \0 as full_hash.
+ const std::string hash_in = "12345678902234567890323456789012";
+ SBFullHash hash_out = StringToSBFullHash(hash_in);
+- EXPECT_EQ(0x34333231U, hash_out.prefix);
++ EXPECT_EQ(htonl(0x31323334U), hash_out.prefix);
+ EXPECT_EQ(0, memcmp(hash_in.data(), hash_out.full_hash, sizeof(SBFullHash)));
+
+ std::string hash_final = SBFullHashToString(hash_out);
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice.cc
@@ -0,0 +1,39 @@
+--- src/3rdparty/chromium/components/safe_browsing/db/v4_rice.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/components/safe_browsing/db/v4_rice.cc
+@@ -8,6 +8,7 @@
+ #include "base/logging.h"
+ #include "base/numerics/safe_math.h"
+ #include "base/strings/stringprintf.h"
++#include "base/sys_byteorder.h"
+ #include "build/build_config.h"
+ #include "components/safe_browsing/db/v4_rice.h"
+
+@@ -21,10 +22,6 @@ using ::google::protobuf::RepeatedField;
+ using ::google::protobuf::int32;
+ using ::google::protobuf::int64;
+
+-#if !defined(ARCH_CPU_LITTLE_ENDIAN) || (ARCH_CPU_LITTLE_ENDIAN != 1)
+-#error The code below assumes little-endianness.
+-#endif
+-
+ namespace safe_browsing {
+
+ namespace {
+@@ -117,7 +114,7 @@ V4DecodeResult V4RiceDecoder::DecodePrefixes(const int
+ out->reserve((num_entries + 1));
+
+ base::CheckedNumeric<uint32_t> last_value(first_value);
+- out->push_back(htonl(last_value.ValueOrDie()));
++ out->push_back(base::ByteSwap(static_cast<uint32_t>(last_value.ValueOrDie())));
+
+ if (num_entries > 0) {
+ V4RiceDecoder decoder(rice_parameter, num_entries, encoded_data);
+@@ -136,7 +133,7 @@ V4DecodeResult V4RiceDecoder::DecodePrefixes(const int
+
+ // This flipping is done so that the decoded uint32 is interpreted
+ // correcly as a string of 4 bytes.
+- out->push_back(htonl(last_value.ValueOrDie()));
++ out->push_back(base::ByteSwap(static_cast<uint32_t>(last_value.ValueOrDie())));
+ }
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice__unittest.cc
@@ -0,0 +1,33 @@
+--- src/3rdparty/chromium/components/safe_browsing/db/v4_rice_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/components/safe_browsing/db/v4_rice_unittest.cc
+@@ -6,6 +6,12 @@
+ #include "base/logging.h"
+ #include "testing/platform_test.h"
+
++#if defined(OS_WIN)
++#include <winsock2.h>
++#elif defined(OS_POSIX)
++#include <arpa/inet.h>
++#endif
++
+ using ::google::protobuf::RepeatedField;
+ using ::google::protobuf::int32;
+
+@@ -247,7 +253,7 @@ TEST_F(V4RiceTest, TestDecoderPrefixesWithOneValue) {
+ EXPECT_EQ(DECODE_SUCCESS,
+ V4RiceDecoder::DecodePrefixes(0x69F67F51u, 2, 0, "", &out));
+ EXPECT_EQ(1u, out.size());
+- EXPECT_EQ(0x69F67F51u, out[0]);
++ EXPECT_EQ(htonl(0x517FF669u), out[0]);
+ }
+
+ TEST_F(V4RiceTest, TestDecoderPrefixesWithMultipleValues) {
+@@ -256,7 +262,7 @@ TEST_F(V4RiceTest, TestDecoderPrefixesWithMultipleValu
+ V4RiceDecoder::DecodePrefixes(
+ 5, 28, 3, "\xbf\xa8\x3f\xfb\xf\xf\x5e\x27\xe6\xc3\x1d\xc6\x38",
+ &out));
+- std::vector<uint32_t> expected = {5, 0xad934c0cu, 0x6ff67f56u, 0x81316fceu};
++ std::vector<uint32_t> expected = {htonl(0x05000000), htonl(0x0c4c93adu), htonl(0x567ff66fu), htonl(0xce6f3181u)};
+ EXPECT_EQ(expected.size(), out.size());
+ for (unsigned i = 0; i < expected.size(); i++) {
+ EXPECT_EQ(expected[i], out[i]);
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc
@@ -1,6 +1,6 @@
---- src/3rdparty/chromium/components/update_client/update_query_params.cc.orig 2018-11-13 18:25:11 UTC
-+++ src/3rdparty/chromium/components/update_client/update_query_params.cc
-@@ -38,6 +38,8 @@ const char kOs[] =
+--- src/3rdparty/chromium/components/update_client/update_query_params.cc.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/components/update_client/update_query_params.cc 2019-10-29 02:42:47.135055000 +0100
+@@ -38,6 +38,8 @@
"fuchsia";
#elif defined(OS_OPENBSD)
"openbsd";
@@ -9,3 +9,21 @@
#else
#error "unknown os"
#endif
+@@ -55,6 +57,8 @@
+ "mips64el";
+ #elif defined(__mips__)
+ "mipsel";
++#elif defined(__powerpc64__)
++ "ppc64";
+ #else
+ #error "unknown arch"
+ #endif
+@@ -127,6 +131,8 @@
+ return "mips32";
+ #elif defined(ARCH_CPU_MIPS64EL)
+ return "mips64";
++#elif defined(ARCH_CPU_PPC64)
++ return "ppc64";
+ #else
+ // NOTE: when adding new values here, please remember to update the
+ // comment in the .h file about possible return values from this function.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_media_ffmpeg_ffmpeg__common.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_media_ffmpeg_ffmpeg__common.cc
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc
+@@ -686,10 +686,6 @@ ChannelLayout ChannelLayoutToChromeChannelLayout(int64
+ }
+ }
+
+-#if !defined(ARCH_CPU_LITTLE_ENDIAN)
+-#error The code below assumes little-endianness.
+-#endif
+-
+ VideoPixelFormat AVPixelFormatToVideoPixelFormat(AVPixelFormat pixel_format) {
+ // The YUVJ alternatives are FFmpeg's (deprecated, but still in use) way to
+ // specify a pixel format and full range color combination.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_media_formats_mp4_box__definitions.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_media_formats_mp4_box__definitions.cc
@@ -0,0 +1,26 @@
+--- src/3rdparty/chromium/media/formats/mp4/box_definitions.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/media/formats/mp4/box_definitions.cc
+@@ -1107,15 +1107,14 @@ bool OpusSpecificBox::Parse(BoxReader* reader) {
+ RCHECK(reader->Read4(&sample_rate));
+ RCHECK(reader->Read2s(&gain_db));
+
+-#if !defined(ARCH_CPU_LITTLE_ENDIAN)
+-#error The code below assumes little-endianness.
+-#endif
+-
+- memcpy(&extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET], &codec_delay_in_frames,
+- sizeof(codec_delay_in_frames));
+- memcpy(&extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET], &sample_rate,
+- sizeof(sample_rate));
+- memcpy(&extradata[OPUS_EXTRADATA_GAIN_OFFSET], &gain_db, sizeof(gain_db));
++ extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET] = (codec_delay_in_frames >> 0) & 0xff;
++ extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET+1] = (codec_delay_in_frames >> 8) & 0xff;
++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET] = (sample_rate >> 0) & 0xff;
++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+1] = (sample_rate >> 8) & 0xff;
++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+2] = (sample_rate >> 16) & 0xff;
++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+3] = (sample_rate >> 24) & 0xff;
++ extradata[OPUS_EXTRADATA_GAIN_OFFSET] = (gain_db >> 0) & 0xff;
++ extradata[OPUS_EXTRADATA_GAIN_OFFSET+1] = (gain_db >> 8) & 0xff;
+
+ channel_count = extradata[OPUS_EXTRADATA_CHANNELS_OFFSET];
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_media_renderers_paint__canvas__video__renderer.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_media_renderers_paint__canvas__video__renderer.cc
@@ -0,0 +1,22 @@
+--- src/3rdparty/chromium/media/renderers/paint_canvas_video_renderer.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/media/renderers/paint_canvas_video_renderer.cc
+@@ -31,8 +31,7 @@
+
+ // Skia internal format depends on a platform. On Android it is ABGR, on others
+ // it is ARGB.
+-#if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \
+- SK_A32_SHIFT == 24
++#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
+ #define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB
+ #define LIBYUV_I422_TO_ARGB libyuv::I422ToARGB
+ #define LIBYUV_I444_TO_ARGB libyuv::I444ToARGB
+@@ -42,8 +41,7 @@
+ #define LIBYUV_I010_TO_ARGB libyuv::I010ToARGB
+ #define LIBYUV_H010_TO_ARGB libyuv::H010ToARGB
+ #define LIBYUV_NV12_TO_ARGB libyuv::NV12ToARGB
+-#elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \
+- SK_A32_SHIFT == 24
++#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
+ #define LIBYUV_I420_TO_ARGB libyuv::I420ToABGR
+ #define LIBYUV_I422_TO_ARGB libyuv::I422ToABGR
+ #define LIBYUV_I444_TO_ARGB libyuv::I444ToABGR
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_net_cert_crl__set.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_net_cert_crl__set.cc
@@ -0,0 +1,48 @@
+--- src/3rdparty/chromium/net/cert/crl_set.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/net/cert/crl_set.cc
+@@ -6,6 +6,7 @@
+
+ #include "base/base64.h"
+ #include "base/json/json_reader.h"
++#include "base/sys_byteorder.h"
+ #include "base/time/time.h"
+ #include "base/trace_event/trace_event.h"
+ #include "base/values.h"
+@@ -44,9 +45,9 @@ base::DictionaryValue* ReadHeader(base::StringPiece* d
+ uint16_t header_len;
+ if (data->size() < sizeof(header_len))
+ return nullptr;
+- // Assumes little-endian.
+ memcpy(&header_len, data->data(), sizeof(header_len));
+ data->remove_prefix(sizeof(header_len));
++ header_len = base::ByteSwapToLE16(header_len);
+
+ if (data->size() < header_len)
+ return nullptr;
+@@ -79,9 +80,9 @@ bool ReadCRL(base::StringPiece* data,
+ uint32_t num_serials;
+ if (data->size() < sizeof(num_serials))
+ return false;
+- // Assumes little endian.
+ memcpy(&num_serials, data->data(), sizeof(num_serials));
+ data->remove_prefix(sizeof(num_serials));
++ num_serials = base::ByteSwapToLE32(num_serials);
+
+ if (num_serials > 32 * 1024 * 1024) // Sanity check.
+ return false;
+@@ -192,15 +193,6 @@ CRLSet::~CRLSet() = default;
+ // static
+ bool CRLSet::Parse(base::StringPiece data, scoped_refptr<CRLSet>* out_crl_set) {
+ TRACE_EVENT0(NetTracingCategory(), "CRLSet::Parse");
+-// Other parts of Chrome assume that we're little endian, so we don't lose
+-// anything by doing this.
+-#if defined(__BYTE_ORDER)
+- // Linux check
+- static_assert(__BYTE_ORDER == __LITTLE_ENDIAN, "assumes little endian");
+-#elif defined(__BIG_ENDIAN__)
+-// Mac check
+-#error assumes little endian
+-#endif
+
+ std::unique_ptr<base::DictionaryValue> header_dict(ReadHeader(&data));
+ if (!header_dict.get())
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_services_service__manager_sandbox_linux_bpf__renderer__policy__linux.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_services_service__manager_sandbox_linux_bpf__renderer__policy__linux.cc
@@ -0,0 +1,14 @@
+--- src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc
+@@ -15,6 +15,11 @@
+ #include "sandbox/linux/system_headers/linux_syscalls.h"
+ #include "services/service_manager/sandbox/linux/sandbox_linux.h"
+
++// On PPC64, TCGETS is defined in terms of struct termios, so we must include termios.h
++#ifdef __powerpc64__
++#include <termios.h>
++#endif
++
+ // TODO(vignatti): replace the local definitions below with #include
+ // <linux/dma-buf.h> once kernel version 4.6 becomes widely used.
+ #include <linux/types.h>
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_config_SkUserConfig.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_config_SkUserConfig.h
@@ -0,0 +1,39 @@
+--- src/3rdparty/chromium/skia/config/SkUserConfig.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/skia/config/SkUserConfig.h
+@@ -90,11 +90,18 @@ SK_API void SkDebugf_FileLine(const char* file, int li
+ __FILE__, __LINE__, #cond); } } while (false)
+
+ #if !defined(ANDROID) // On Android, we use the skia default settings.
++#if defined(SK_CPU_BENDIAN)
++#define SK_A32_SHIFT 0
++#define SK_R32_SHIFT 8
++#define SK_G32_SHIFT 16
++#define SK_B32_SHIFT 24
++#else
+ #define SK_A32_SHIFT 24
+ #define SK_R32_SHIFT 16
+ #define SK_G32_SHIFT 8
+ #define SK_B32_SHIFT 0
+ #endif
++#endif
+
+ #if defined(SK_BUILD_FOR_MAC)
+
+@@ -107,17 +114,6 @@ SK_API void SkDebugf_FileLine(const char* file, int li
+ // TODO: skia used to just use hairline, but has improved since then, so
+ // we should revisit this choice...
+ #define SK_USE_FREETYPE_EMBOLDEN
+-
+-#if defined(SK_BUILD_FOR_UNIX) && defined(SK_CPU_BENDIAN)
+-// Above we set the order for ARGB channels in registers. I suspect that, on
+-// big endian machines, you can keep this the same and everything will work.
+-// The in-memory order will be different, of course, but as long as everything
+-// is reading memory as words rather than bytes, it will all work. However, if
+-// you find that colours are messed up I thought that I would leave a helpful
+-// locator for you. Also see the comments in
+-// base/gfx/bitmap_platform_device_linux.h
+-#error Read the comment at this location
+-#endif
+
+ #endif
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_ext_image__operations__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_ext_image__operations__unittest.cc
@@ -0,0 +1,59 @@
+--- src/3rdparty/chromium/skia/ext/image_operations_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/skia/ext/image_operations_unittest.cc
+@@ -18,9 +18,11 @@
+ #include "skia/ext/image_operations.h"
+ #include "testing/gtest/include/gtest/gtest.h"
+ #include "third_party/skia/include/core/SkBitmap.h"
++#include "third_party/skia/include/core/SkColorPriv.h"
+ #include "third_party/skia/include/core/SkColorSpace.h"
+ #include "third_party/skia/include/core/SkImageInfo.h"
+ #include "third_party/skia/include/core/SkRect.h"
++#include "third_party/skia/include/core/SkUnPreMultiply.h"
+ #include "ui/gfx/codec/png_codec.h"
+ #include "ui/gfx/geometry/size.h"
+
+@@ -151,7 +153,7 @@ void DrawCheckerToBitmap(int w, int h,
+
+ bool use_color2 = (x_bit != y_bit); // xor
+
+- *bmp->getAddr32(x, y) = (use_color2 ? color2 : color1);
++ *bmp->getAddr32(x, y) = SkPreMultiplyColor(use_color2 ? color2 : color1);
+ }
+ }
+ }
+@@ -273,7 +275,7 @@ void CheckResizeMethodShouldAverageGrid(
+ std::max(tested_pixel.max_color_distance,
+ tested_method.max_color_distance_override);
+
+- const SkColor actual_color = *dest.getAddr32(x, y);
++ const SkColor actual_color = SkUnPreMultiply::PMColorToColor(*dest.getAddr32(x, y));
+
+ // Check that the pixels away from the border region are very close
+ // to the expected average color
+@@ -528,7 +530,7 @@ TEST(ImageOperations, ScaleUp) {
+ for (int src_y = 0; src_y < src_h; ++src_y) {
+ for (int src_x = 0; src_x < src_w; ++src_x) {
+ *src.getAddr32(src_x, src_y) =
+- SkColorSetARGB(255, 10 + src_x * 100, 10 + src_y * 100, 0);
++ SkPackARGB32(255, 10 + src_x * 100, 10 + src_y * 100, 0);
+ }
+ }
+
+@@ -552,7 +554,7 @@ TEST(ImageOperations, ScaleUp) {
+ lanczos3(src_x + 0.5 - dst_x_in_src) *
+ lanczos3(src_y + 0.5 - dst_y_in_src);
+ sum += coeff;
+- SkColor tmp = *src.getAddr32(src_x, src_y);
++ SkColor tmp = SkUnPreMultiply::PMColorToColor(*src.getAddr32(src_x, src_y));
+ a += coeff * SkColorGetA(tmp);
+ r += coeff * SkColorGetR(tmp);
+ g += coeff * SkColorGetG(tmp);
+@@ -571,7 +573,7 @@ TEST(ImageOperations, ScaleUp) {
+ if (r > 255.0f) r = 255.0f;
+ if (g > 255.0f) g = 255.0f;
+ if (b > 255.0f) b = 255.0f;
+- SkColor dst_color = *dst.getAddr32(dst_x, dst_y);
++ SkColor dst_color = SkUnPreMultiply::PMColorToColor(*dst.getAddr32(dst_x, dst_y));
+ EXPECT_LE(fabs(SkColorGetA(dst_color) - a), 1.5f);
+ EXPECT_LE(fabs(SkColorGetR(dst_color) - r), 1.5f);
+ EXPECT_LE(fabs(SkColorGetG(dst_color) - g), 1.5f);
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_abseil-cpp_base_internal_unscaledcycleclock.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_abseil-cpp_base_internal_unscaledcycleclock.cc
@@ -0,0 +1,20 @@
+--- src/3rdparty/chromium/third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc 2019-10-27 21:56:29.777821000 +0100
+@@ -20,7 +20,7 @@
+ #include <intrin.h>
+ #endif
+
+-#if defined(__powerpc__) || defined(__ppc__)
++#if (defined(__powerpc__) || defined(__ppc__)) && defined(__GLIBC__)
+ #include <sys/platform/ppc.h>
+ #endif
+
+@@ -53,7 +53,7 @@
+ return base_internal::NominalCPUFrequency();
+ }
+
+-#elif defined(__powerpc__) || defined(__ppc__)
++#elif (defined(__powerpc__) || defined(__ppc__)) && defined(__GLIBC__)
+
+ int64_t UnscaledCycleClock::Now() {
+ return __ppc_get_timebase();
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_angle_src_libANGLE_Constants.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_angle_src_libANGLE_Constants.h
@@ -0,0 +1,10 @@
+--- src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h
+@@ -9,6 +9,7 @@
+ #ifndef LIBANGLE_CONSTANTS_H_
+ #define LIBANGLE_CONSTANTS_H_
+
++#include <cstddef>
+ #include "common/platform.h"
+
+ namespace gl
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion.cc
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion.cc
+@@ -456,8 +456,8 @@ void Unpack<WebGLImageConversion::kDataFormatBGRA8, ui
+ for (unsigned i = 0; i < pixels_per_row; ++i) {
+ uint32_t bgra = source32[i];
+ #if defined(ARCH_CPU_BIG_ENDIAN)
+- uint32_t brMask = 0xff00ff00;
+- uint32_t gaMask = 0x00ff00ff;
++ uint32_t br_mask = 0xff00ff00;
++ uint32_t ga_mask = 0x00ff00ff;
+ #else
+ uint32_t br_mask = 0x00ff00ff;
+ uint32_t ga_mask = 0xff00ff00;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion__test.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion__test.cc
@@ -0,0 +1,15 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion_test.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion_test.cc
+@@ -76,9 +76,9 @@ TEST_F(WebGLImageConversionTest, convertBGRA8toRGBA8)
+ 0x34567888, 0x12345678, 0x34567888,
+ 0x12345678, 0x34567888, 0x12345678};
+ #if defined(ARCH_CPU_BIG_ENDIAN)
+- uint32_t expectedData[9] = {0x56341278, 0x78563488, 0x56341278,
+- 0x78563488, 0x56341278, 0x78563488,
+- 0x56341278, 0x78563488, 0x56341278};
++ uint32_t expected_data[9] = {0x56341278, 0x78563488, 0x56341278,
++ 0x78563488, 0x56341278, 0x78563488,
++ 0x56341278, 0x78563488, 0x56341278};
+ #else
+ uint32_t expected_data[9] = {0x12785634, 0x34887856, 0x12785634,
+ 0x34887856, 0x12785634, 0x34887856,
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_graphics__context__test.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_graphics__context__test.cc
@@ -0,0 +1,134 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/graphics_context_test.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/graphics_context_test.cc
+@@ -52,7 +52,7 @@ namespace blink {
+ { \
+ for (int y = opaqueRect.Y(); y < opaqueRect.MaxY(); ++y) \
+ for (int x = opaqueRect.X(); x < opaqueRect.MaxX(); ++x) { \
+- int alpha = *bitmap.getAddr32(x, y) >> 24; \
++ int alpha = SkGetPackedA32(*bitmap.getAddr32(x, y)); \
+ EXPECT_EQ(255, alpha); \
+ } \
+ }
+@@ -61,12 +61,16 @@ namespace blink {
+ { \
+ for (int y = 0; y < bitmap.height(); ++y) \
+ for (int x = 0; x < bitmap.width(); ++x) { \
+- int alpha = *bitmap.getAddr32(x, y) >> 24; \
++ int alpha = SkGetPackedA32(*bitmap.getAddr32(x, y)); \
+ bool opaque = opaqueRect.Contains(x, y); \
+ EXPECT_EQ(opaque, alpha == 255); \
+ } \
+ }
+
++static inline uint32_t PackARGB32(uint32_t argb) {
++ return SkPackARGB32NoCheck(argb>>24, (argb<<8)>>24, (argb<<16)>>24, (argb<<24)>>24);
++}
++
+ TEST(GraphicsContextTest, Recording) {
+ SkBitmap bitmap;
+ bitmap.allocN32Pixels(100, 100);
+@@ -184,10 +188,10 @@ class GraphicsContextHighConstrastTest : public testin
+ TEST_F(GraphicsContextHighConstrastTest, MAYBE_NoHighContrast) {
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xff808080, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xff808080), *bitmap_.getAddr32(3, 0));
+ }
+
+ // TODO(crbug.com/850782): Reenable this.
+@@ -205,10 +209,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_HighCon
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xff808080, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xff808080), *bitmap_.getAddr32(3, 0));
+ }
+
+ // Simple invert for testing. Each color component |c|
+@@ -228,10 +232,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_SimpleI
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xff00ffff, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xff7f7f7f, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xff00ffff), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xff7f7f7f), *bitmap_.getAddr32(3, 0));
+ }
+
+ // Invert brightness (with gamma correction).
+@@ -250,10 +254,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertB
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xff00ffff, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xff00ffff), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0));
+ }
+
+ // Invert lightness (in HSL space).
+@@ -272,10 +276,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertL
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0));
+ }
+
+ // Invert lightness plus grayscale.
+@@ -288,10 +292,10 @@ TEST_F(GraphicsContextHighConstrastTest, InvertLightne
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xffe2e2e2, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xffe2e2e2), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0));
+ }
+
+ // TODO(crbug.com/850782): Reenable this.
+@@ -309,10 +313,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertL
+
+ DrawColorsToContext();
+
+- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0));
+- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0));
+- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0));
+- EXPECT_EQ(0xffeeeeee, *bitmap_.getAddr32(3, 0));
++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0));
++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0));
++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0));
++ EXPECT_EQ(PackARGB32(0xffeeeeee), *bitmap_.getAddr32(3, 0));
+ }
+
+ } // namespace blink
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_highcontrast_highcontrast__classifier.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_highcontrast_highcontrast__classifier.cc
@@ -0,0 +1,79 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/highcontrast/highcontrast_classifier.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/highcontrast/highcontrast_classifier.cc
+@@ -1060,55 +1060,47 @@ void DequantizeMinFirst(const int32_t rank,
+
+ // -----------------------------------------------------------------------------
+ // CONSTANTS
+-// Note that for now, endianness of the target machine needs to match that of
+-// the one training was performed on.
+ // -----------------------------------------------------------------------------
+ const int32_t dnn_hiddenlayer_0_weights_part_0_shape[2] = {4, 10};
+ const union {
+- uint8_t bytes[160];
+ float values[40];
+ } dnn_hiddenlayer_0_weights_part_0 = {{
+- 0xbc, 0x22, 0x0a, 0xbf, 0xb4, 0x46, 0x8c, 0x3f, 0xba, 0x31, 0x34, 0xbe,
+- 0x4c, 0x65, 0xdb, 0xbe, 0xf0, 0x54, 0x5e, 0xbe, 0xc1, 0x5d, 0xb3, 0x3f,
+- 0xf4, 0xe6, 0x15, 0xbf, 0x05, 0xc6, 0x34, 0xbf, 0xc0, 0x37, 0x7e, 0xbd,
+- 0x6c, 0x35, 0x0b, 0xbf, 0xca, 0x53, 0x26, 0xbf, 0x58, 0xb4, 0x87, 0x3f,
+- 0x37, 0xee, 0x39, 0xbf, 0xda, 0xfa, 0xf9, 0xbe, 0x97, 0xc1, 0x06, 0xbf,
+- 0xf9, 0x4e, 0x81, 0x3f, 0xb2, 0x44, 0x85, 0xbf, 0x7f, 0x98, 0x7c, 0x3d,
+- 0x15, 0x26, 0xbc, 0xbe, 0x5c, 0x48, 0x05, 0x3f, 0xc8, 0xaa, 0xa1, 0xbd,
+- 0x35, 0xb3, 0x43, 0xbe, 0xeb, 0x46, 0x91, 0x3f, 0x80, 0x71, 0xe3, 0x3c,
+- 0xd1, 0x98, 0x79, 0x3f, 0x3c, 0xd0, 0x0d, 0xbf, 0x1e, 0x02, 0xd3, 0x3e,
+- 0x5d, 0x4b, 0xa2, 0xbf, 0x68, 0xac, 0xaa, 0xbd, 0xf8, 0xe1, 0x75, 0x3e,
+- 0x4a, 0x9c, 0x27, 0xbe, 0xf8, 0xae, 0xb2, 0xbe, 0x7f, 0x9d, 0x91, 0x3f,
+- 0x1e, 0x8b, 0xa8, 0xbe, 0x35, 0x7e, 0xb2, 0x3f, 0xbe, 0x8c, 0xd3, 0xbe,
+- 0xf9, 0xcd, 0xb5, 0x3f, 0xa1, 0x50, 0xaa, 0x3f, 0xe4, 0x6d, 0xdd, 0xbe,
+- 0x0d, 0xce, 0xd3, 0xbe,
++ -0.539592504501343, 1.09590768814087, -0.175970941781998, -0.428507208824158,
++ -0.217120885848999, 1.40129864215851, -0.5855553150177, -0.706146538257599,
++ -0.0620648860931396, -0.543783903121948, -0.649716019630432, 1.06019115447998,
++ -0.726291120052338, -0.488241970539093, -0.526391446590424, 1.01022255420685,
++ -1.04115891456604, 0.0616688691079617, -0.367478042840958, 0.520635366439819,
++ -0.0789390206336975, -0.19111330807209, 1.13497674465179, 0.0277640819549561,
++ 0.974988043308258, -0.553958654403687, 0.412125527858734, -1.2679249048233,
++ -0.0833366513252258, 0.240119814872742, -0.163682132959366, -0.34899115562439,
++ 1.1376188993454, -0.329186379909515, 1.3944765329361, -0.413183152675629,
++ 1.42034828662872, 1.33058559894562, -0.432479023933411, -0.413681417703629
+ }};
+ const int32_t dnn_hiddenlayer_0_biases_part_0_shape[1] = {10};
+ const union {
+- uint8_t bytes[40];
+ float values[10];
+ } dnn_hiddenlayer_0_biases_part_0 = {{
+- 0x00, 0x00, 0x00, 0x00, 0xbf, 0x6a, 0x53, 0x3e, 0xd3, 0xc1,
+- 0xd0, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xd8, 0xc0, 0x3e,
+- 0xca, 0xe7, 0x35, 0x3e, 0x23, 0xa5, 0x44, 0x3f, 0x61, 0xfd,
+- 0xd2, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xe0, 0x43, 0x3c,
++ 0.0, 0.206461891531944,
++ 0.407728761434555, 0.0,
++ 0.376653373241425, 0.177642017602921,
++ 0.76814478635788, 0.412089377641678,
++ 0.0, 0.0119554307311773
+ }};
+ const int32_t dnn_logits_biases_part_0_shape[1] = {1};
+ const union {
+- uint8_t bytes[4];
+ float values[1];
+ } dnn_logits_biases_part_0 = {{
+- 0x75, 0xca, 0xd7, 0xbe,
++ -0.421466499567032
+ }};
+ const int32_t dnn_logits_weights_part_0_shape[2] = {10, 1};
+ const union {
+- uint8_t bytes[40];
+ float values[10];
+ } dnn_logits_weights_part_0 = {{
+- 0x13, 0x12, 0x39, 0x3f, 0xf3, 0xa5, 0xc2, 0xbf, 0x81, 0x7f,
+- 0xbe, 0x3f, 0xf8, 0x17, 0x26, 0x3e, 0xa4, 0x19, 0xa6, 0x3f,
+- 0xf0, 0xc9, 0xb7, 0xbf, 0x6a, 0x99, 0xd2, 0x3f, 0x8a, 0x7d,
+- 0xe9, 0x3f, 0x83, 0x9a, 0x3a, 0xbf, 0xf1, 0x6c, 0x08, 0x3e,
++ 0.722932040691376, -1.52068936824799,
++ 1.48826611042023, 0.162200808525085,
++ 1.29765748977661, -1.43585014343262,
++ 1.64530682563782, 1.82414364814758,
++ -0.728920161724091, 0.133228078484535
+ }};
+
+ } // anonymous namespace
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_BUILD.gn
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_BUILD.gn
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn
+@@ -46,6 +46,10 @@ if (current_cpu == "x86" || current_cpu == "x64") {
+ sources = [
+ "SaveRegisters_mips64.S",
+ ]
++ } else if (current_cpu == "ppc64") {
++ sources = [
++ "SaveRegisters_ppc64.S",
++ ]
+ }
+
+ if (current_cpu == "arm") {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_SaveRegisters__ppc64.S
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_SaveRegisters__ppc64.S
@@ -0,0 +1,63 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S.orig 2019-10-27 17:23:52 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S
+@@ -0,0 +1,60 @@
++/*
++ * typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*);
++ * extern "C" void PushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback)
++ */
++
++.type PushAllRegisters, %function
++.global PushAllRegisters
++.hidden PushAllRegisters
++PushAllRegisters:
++ // Push all callee-saves registers to get them
++ // on the stack for conservative stack scanning.
++ // Reserve space for callee-saved registers and minimal stack frame.
++ mflr 0 # r0 = LR
++ std 0,16(1) # store LR at addr sp+16
++ stdu 1,-176(1) # grow stack by 176 bytes and store new stack top ptr to r1
++ # 3218*8 = min stack non-volatile registers
++
++ // Save the callee-saved registers
++ std 31,168(1) # store r31 to addr sp+168
++ std 30,160(1) # etc...
++ std 29,152(1)
++ std 28,144(1)
++ std 27,136(1)
++ std 26,128(1)
++ std 25,120(1)
++ std 24,112(1)
++ std 23,104(1)
++ std 22,96(1)
++ std 21,88(1)
++ std 20,80(1)
++ std 19,72(1)
++ std 18,64(1)
++ std 17,56(1)
++ std 16,48(1)
++ std 15,40(1)
++ std 14,32(1)
++
++ // Note: the callee-saved floating point registers do not need to be
++ // copied to the stack, because fp registers never hold heap pointers
++ // and so do not need to be kept visible to the garbage collector.
++
++ // Pass the two first arguments untouched in r3 and r4 and the
++ // stack pointer to the callback.
++
++ std 2, 24(1) # save r2 to sp+24 addr
++ mtctr 5 # copy 3rd function arg (callback fn pointer) to CTR
++ mr 12, 5 # r12 must hold address of callback we are going to call
++ # for position-idependent functions inside the callback to work
++ mr 5, 1 # set current sp (stack top) as 3rd argument for the callback
++ bctrl # set LR to PC+4 and call the callback
++ ld 2, 24(1) # restore r2 from sp+24 addr
++
++ // Adjust stack, restore return address and return.
++ // Note: the copied registers do not need to be reloaded here,
++ // because they were preserved by the called routine.
++ addi 1,1,176 # restore original SP by doing sp += 176
++ ld 0,16(1) # restore original LR from addr sp+16
++ mtlr 0 # ... copy it to the actual LR
++ blr # return to LR addr
++
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_bmp_bmp__image__reader.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_bmp_bmp__image__reader.h
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/bmp/bmp_image_reader.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/bmp/bmp_image_reader.h
+@@ -37,6 +37,7 @@
+ #include "third_party/blink/renderer/platform/wtf/allocator.h"
+ #include "third_party/blink/renderer/platform/wtf/cpu.h"
+ #include "third_party/blink/renderer/platform/wtf/noncopyable.h"
++#include "base/sys_byteorder.h"
+
+ namespace blink {
+
+@@ -50,11 +51,11 @@ class PLATFORM_EXPORT BMPImageReader final {
+ // Read a value from |buffer|, converting to an int assuming little
+ // endianness
+ static inline uint16_t ReadUint16(const char* buffer) {
+- return *reinterpret_cast<const uint16_t*>(buffer);
++ return base::ByteSwapToLE16(*reinterpret_cast<const uint16_t*>(buffer));
+ }
+
+ static inline uint32_t ReadUint32(const char* buffer) {
+- return *reinterpret_cast<const uint32_t*>(buffer);
++ return base::ByteSwapToLE32(*reinterpret_cast<const uint32_t*>(buffer));
+ }
+
+ // |parent| is the decoder that owns us.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_jpeg_jpeg__image__decoder.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_jpeg_jpeg__image__decoder.cc
@@ -0,0 +1,40 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/jpeg/jpeg_image_decoder.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/jpeg/jpeg_image_decoder.cc
+@@ -49,23 +49,30 @@ extern "C" {
+ #include <setjmp.h>
+ }
+
+-#if defined(ARCH_CPU_BIG_ENDIAN)
+-#error Blink assumes a little-endian target.
+-#endif
+-
+ #if defined(JCS_ALPHA_EXTENSIONS)
+ #define TURBO_JPEG_RGB_SWIZZLE
+-#if SK_B32_SHIFT // Output little-endian RGBA pixels (Android).
++#if SK_PMCOLOR_BYTE_ORDER(R, G, B, A)
+ inline J_COLOR_SPACE rgbOutputColorSpace() {
+ return JCS_EXT_RGBA;
+ }
+-#else // Output little-endian BGRA pixels.
++#elif SK_PMCOLOR_BYTE_ORDER(B, G, R, A)
+ inline J_COLOR_SPACE rgbOutputColorSpace() {
+ return JCS_EXT_BGRA;
+ }
++#elif SK_PMCOLOR_BYTE_ORDER(A, R, G, B)
++inline J_COLOR_SPACE rgbOutputColorSpace() {
++ return JCS_EXT_ARGB;
++}
++#elif SK_PMCOLOR_BYTE_ORDER(A, B, G, R)
++inline J_COLOR_SPACE rgbOutputColorSpace() {
++ return JCS_EXT_ABGR;
++}
++#else
++#error Component order not supported by libjpeg_turbo
+ #endif
+ inline bool turboSwizzled(J_COLOR_SPACE colorSpace) {
+- return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA;
++ return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA ||
++ colorSpace == JCS_EXT_ABGR || colorSpace == JCS_EXT_ARGB;
+ }
+ #else
+ inline J_COLOR_SPACE rgbOutputColorSpace() {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_webp_webp__image__decoder.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_webp_webp__image__decoder.cc
@@ -0,0 +1,29 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/webp/webp_image_decoder.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/webp/webp_image_decoder.cc
+@@ -32,18 +32,20 @@
+ #include "third_party/blink/renderer/platform/histogram.h"
+ #include "third_party/skia/include/core/SkData.h"
+
+-#if defined(ARCH_CPU_BIG_ENDIAN)
+-#error Blink assumes a little-endian target.
+-#endif
+-
+-#if SK_B32_SHIFT // Output little-endian RGBA pixels (Android).
++#if SK_PMCOLOR_BYTE_ORDER(R, G, B, A)
+ inline WEBP_CSP_MODE outputMode(bool hasAlpha) {
+ return hasAlpha ? MODE_rgbA : MODE_RGBA;
+ }
+-#else // Output little-endian BGRA pixels.
++#elif SK_PMCOLOR_BYTE_ORDER(B, G, R, A)
+ inline WEBP_CSP_MODE outputMode(bool hasAlpha) {
+ return hasAlpha ? MODE_bgrA : MODE_BGRA;
+ }
++#elif SK_PMCOLOR_BYTE_ORDER(A, R, G, B)
++inline WEBP_CSP_MODE outputMode(bool hasAlpha) {
++ return hasAlpha ? MODE_Argb : MODE_ARGB;
++}
++#else
++#error Component order not supported by libwebp
+ #endif
+
+ namespace {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_wtf_dtoa_utils.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_wtf_dtoa_utils.h
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h
+@@ -45,7 +45,7 @@
+ // disabled.)
+ // On Linux,x86 89255e-22 != Div_double(89255.0/1e22)
+ #if defined(_M_X64) || defined(__x86_64__) || defined(__ARMEL__) || \
+- defined(__aarch64__) || defined(__MIPSEL__)
++ defined(__aarch64__) || defined(__MIPSEL__) || defined(__powerpc64__)
+ #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
+ #elif defined(_M_IX86) || defined(__i386__)
+ #if defined(_WIN32)
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn
@@ -1,6 +1,6 @@
---- src/3rdparty/chromium/third_party/boringssl/BUILD.gn.orig 2018-11-13 18:25:11 UTC
-+++ src/3rdparty/chromium/third_party/boringssl/BUILD.gn
-@@ -72,7 +72,7 @@ if (is_win && !is_msan) {
+--- src/3rdparty/chromium/third_party/boringssl/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/third_party/boringssl/BUILD.gn 2019-10-29 02:28:30.690043000 +0100
+@@ -71,7 +77,7 @@
} else if (current_cpu == "x64") {
if (is_mac) {
sources += crypto_sources_mac_x86_64
@@ -9,7 +9,7 @@
sources += crypto_sources_linux_x86_64
} else {
public_configs = [ ":no_asm_config" ]
-@@ -80,13 +80,13 @@ if (is_win && !is_msan) {
+@@ -79,13 +85,13 @@
} else if (current_cpu == "x86") {
if (is_mac) {
sources += crypto_sources_mac_x86
@@ -25,7 +25,7 @@
sources += crypto_sources_linux_arm
} else if (is_ios) {
sources += crypto_sources_ios_arm
-@@ -94,7 +94,7 @@ if (is_win && !is_msan) {
+@@ -93,10 +99,17 @@
public_configs = [ ":no_asm_config" ]
}
} else if (current_cpu == "arm64") {
@@ -34,3 +34,13 @@
sources += crypto_sources_linux_aarch64
} else if (is_ios) {
sources += crypto_sources_ios_aarch64
++ } else {
++ public_configs = [ ":no_asm_config" ]
++ }
++ } else if (current_cpu == "ppc64") {
++ if (is_linux || is_bsd) {
++ # TODO: ppc64 (be) check
++ sources += crypto_sources_linux_ppc64le
+ } else {
+ public_configs = [ ":no_asm_config" ]
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_asn1_a__int.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_asn1_a__int.c
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/asn1/a_int.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/asn1/a_int.c
+@@ -369,7 +369,9 @@ int ASN1_INTEGER_set_uint64(ASN1_INTEGER *out, uint64_
+
+ OPENSSL_free(out->data);
+ out->data = newdata;
++#ifndef OPENSSL_BIGENDIAN
+ v = CRYPTO_bswap8(v);
++#endif
+ memcpy(out->data, &v, sizeof(v));
+
+ out->type = V_ASN1_INTEGER;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_chacha_chacha.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_chacha_chacha.c
@@ -0,0 +1,77 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/chacha/chacha.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/chacha/chacha.c
+@@ -29,6 +29,14 @@
+ (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \
+ ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24))
+
++#define U32TO8_LITTLE(p, v) \
++ { \
++ (p)[0] = (v >> 0) & 0xff; \
++ (p)[1] = (v >> 8) & 0xff; \
++ (p)[2] = (v >> 16) & 0xff; \
++ (p)[3] = (v >> 24) & 0xff; \
++ }
++
+ // sigma contains the ChaCha constants, which happen to be an ASCII string.
+ static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3',
+ '2', '-', 'b', 'y', 't', 'e', ' ', 'k' };
+@@ -45,10 +53,28 @@ static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a',
+ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32],
+ const uint8_t nonce[16]) {
+ uint32_t x[16];
+- OPENSSL_memcpy(x, sigma, sizeof(sigma));
+- OPENSSL_memcpy(&x[4], key, 32);
+- OPENSSL_memcpy(&x[12], nonce, 16);
++ int i;
+
++ x[0] = U8TO32_LITTLE(sigma + 0);
++ x[1] = U8TO32_LITTLE(sigma + 4);
++ x[2] = U8TO32_LITTLE(sigma + 8);
++ x[3] = U8TO32_LITTLE(sigma + 12);
++
++ x[4] = U8TO32_LITTLE(key + 0);
++ x[5] = U8TO32_LITTLE(key + 4);
++ x[6] = U8TO32_LITTLE(key + 8);
++ x[7] = U8TO32_LITTLE(key + 12);
++
++ x[8] = U8TO32_LITTLE(key + 16);
++ x[9] = U8TO32_LITTLE(key + 20);
++ x[10] = U8TO32_LITTLE(key + 24);
++ x[11] = U8TO32_LITTLE(key + 28);
++
++ x[12] = U8TO32_LITTLE(nonce + 0);
++ x[13] = U8TO32_LITTLE(nonce + 4);
++ x[14] = U8TO32_LITTLE(nonce + 8);
++ x[15] = U8TO32_LITTLE(nonce + 12);
++
+ for (size_t i = 0; i < 20; i += 2) {
+ QUARTERROUND(0, 4, 8, 12)
+ QUARTERROUND(1, 5, 9, 13)
+@@ -60,8 +86,10 @@ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t k
+ QUARTERROUND(3, 4, 9, 14)
+ }
+
+- OPENSSL_memcpy(out, &x[0], sizeof(uint32_t) * 4);
+- OPENSSL_memcpy(&out[16], &x[12], sizeof(uint32_t) * 4);
++ for (i = 0; i < 4; ++i) {
++ U32TO8_LITTLE(out + 4 * i, x[i]);
++ U32TO8_LITTLE(&out[16] + 4 * i, x[12+i]);
++ }
+ }
+
+ #if !defined(OPENSSL_NO_ASM) && \
+@@ -104,14 +132,6 @@ void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in,
+ }
+
+ #else
+-
+-#define U32TO8_LITTLE(p, v) \
+- { \
+- (p)[0] = (v >> 0) & 0xff; \
+- (p)[1] = (v >> 8) & 0xff; \
+- (p)[2] = (v >> 16) & 0xff; \
+- (p)[3] = (v >> 24) & 0xff; \
+- }
+
+ // chacha_core performs 20 rounds of ChaCha on the input words in
+ // |input| and writes the 64 output bytes to |output|.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_cipher__extra_e__aesgcmsiv.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_cipher__extra_e__aesgcmsiv.c
@@ -0,0 +1,28 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c
+@@ -625,7 +625,11 @@ static void gcm_siv_crypt(uint8_t *out, const uint8_t
+ for (size_t done = 0; done < in_len;) {
+ uint8_t keystream[AES_BLOCK_SIZE];
+ enc_block(counter.c, keystream, key);
++#ifdef OPENSSL_BIGENDIAN
++ counter.w[0] = CRYPTO_bswap4(CRYPTO_bswap4(counter.w[0]) + 1);
++#else
+ counter.w[0]++;
++#endif
+
+ size_t todo = AES_BLOCK_SIZE;
+ if (in_len - done < todo) {
+@@ -673,8 +677,13 @@ static void gcm_siv_polyval(
+ } bitlens;
+ } length_block;
+
++#ifdef OPENSSL_BIGENDIAN
++ length_block.bitlens.ad = CRYPTO_bswap8(ad_len * 8);
++ length_block.bitlens.in = CRYPTO_bswap8(in_len * 8);
++#else
+ length_block.bitlens.ad = ad_len * 8;
+ length_block.bitlens.in = in_len * 8;
++#endif
+ CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block.c,
+ sizeof(length_block));
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_compiler__test.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_compiler__test.cc
@@ -0,0 +1,17 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc
+@@ -40,9 +40,13 @@ static void CheckRepresentation(T value) {
+ UnsignedT value_u = static_cast<UnsignedT>(value);
+ EXPECT_EQ(sizeof(UnsignedT), sizeof(T));
+
+- // Integers must be little-endian.
++ // Integers must be either big-endian or little-endian.
+ uint8_t expected[sizeof(UnsignedT)];
++#ifdef OPENSSL_BIGENDIAN
++ for (size_t i = sizeof(UnsignedT); i-- > 0; ) {
++#else
+ for (size_t i = 0; i < sizeof(UnsignedT); i++) {
++#endif
+ expected[i] = static_cast<uint8_t>(value_u);
+ // Divide instead of right-shift to appease compilers that warn if |T| is a
+ // char. The explicit cast is also needed to appease MSVC if integer
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_curve25519_spake25519.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_curve25519_spake25519.c
@@ -0,0 +1,36 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/curve25519/spake25519.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/curve25519/spake25519.c
+@@ -339,8 +339,17 @@ static void scalar_double(scalar *s) {
+ uint32_t carry = 0;
+
+ for (size_t i = 0; i < 8; i++) {
+- const uint32_t carry_out = s->words[i] >> 31;
+- s->words[i] = (s->words[i] << 1) | carry;
++#ifdef OPENSSL_BIGENDIAN
++ const uint32_t si = CRYPTO_bswap4(s->words[i]);
++#else
++ const uint32_t si = s->words[i];
++#endif
++ const uint32_t carry_out = si >> 31;
++#ifdef OPENSSL_BIGENDIAN
++ s->words[i] = CRYPTO_bswap4((si << 1) | carry);
++#else
++ s->words[i] = (si << 1) | carry;
++#endif
+ carry = carry_out;
+ }
+ }
+@@ -350,8 +359,13 @@ static void scalar_add(scalar *dest, const scalar *src
+ uint32_t carry = 0;
+
+ for (size_t i = 0; i < 8; i++) {
++#ifdef OPENSSL_BIGENDIAN
++ uint64_t tmp = ((uint64_t)CRYPTO_bswap4(dest->words[i]) + CRYPTO_bswap4(src->words[i])) + carry;
++ dest->words[i] = CRYPTO_bswap4((uint32_t)tmp);
++#else
+ uint64_t tmp = ((uint64_t)dest->words[i] + src->words[i]) + carry;
+ dest->words[i] = (uint32_t)tmp;
++#endif
+ carry = (uint32_t)(tmp >> 32);
+ }
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_evp_scrypt.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_evp_scrypt.c
@@ -0,0 +1,30 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/evp/scrypt.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/evp/scrypt.c
+@@ -196,9 +196,27 @@ int EVP_PBE_scrypt(const char *password, size_t passwo
+ goto err;
+ }
+
++#ifdef OPENSSL_BIGENDIAN
++ uint32_t *B32 = B->words;
++ size_t B_words = B_bytes >> 2;
++ do {
++ *B32 = CRYPTO_bswap4(*B32);
++ B32++;
++ } while(--B_words);
++#endif
++
+ for (uint64_t i = 0; i < p; i++) {
+ scryptROMix(B + 2 * r * i, r, N, T, V);
+ }
++
++#ifdef OPENSSL_BIGENDIAN
++ B32 = B->words;
++ B_words = B_bytes >> 2;
++ do {
++ *B32 = CRYPTO_bswap4(*B32);
++ B32++;
++ } while(--B_words);
++#endif
+
+ if (!PKCS5_PBKDF2_HMAC(password, password_len, (const uint8_t *)B, B_bytes, 1,
+ EVP_sha256(), key_len, out_key)) {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_bn_bytes.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_bn_bytes.c
@@ -0,0 +1,64 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/bn/bytes.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/bn/bytes.c
+@@ -136,9 +136,13 @@ BIGNUM *BN_le2bn(const uint8_t *in, size_t len, BIGNUM
+ // Make sure the top bytes will be zeroed.
+ ret->d[num_words - 1] = 0;
+
+- // We only support little-endian platforms, so we can simply memcpy the
+- // internal representation.
++#ifdef OPENSSL_BIGENDIAN
++ uint8_t *out = (uint8_t *)ret->d;
++ for (size_t i = 0; i < len; i++)
++ out[i ^ (BN_BYTES-1)] = in[i];
++#else
+ OPENSSL_memcpy(ret->d, in, len);
++#endif
+ return ret;
+ }
+
+@@ -157,7 +161,11 @@ size_t BN_bn2bin(const BIGNUM *in, uint8_t *out) {
+ static int fits_in_bytes(const uint8_t *bytes, size_t num_bytes, size_t len) {
+ uint8_t mask = 0;
+ for (size_t i = len; i < num_bytes; i++) {
++#ifdef OPENSSL_BIGENDIAN
++ mask |= bytes[i ^ (BN_BYTES-1)];
++#else
+ mask |= bytes[i];
++#endif
+ }
+ return mask == 0;
+ }
+@@ -172,9 +180,13 @@ int BN_bn2le_padded(uint8_t *out, size_t len, const BI
+ num_bytes = len;
+ }
+
+- // We only support little-endian platforms, so we can simply memcpy into the
+- // internal representation.
++#ifdef OPENSSL_BIGENDIAN
++ for (size_t i = 0; i < num_bytes; i++) {
++ out[i] = bytes[i ^ (BN_BYTES-1)];
++ }
++#else
+ OPENSSL_memcpy(out, bytes, num_bytes);
++#endif
+ // Pad out the rest of the buffer with zeroes.
+ OPENSSL_memset(out + num_bytes, 0, len - num_bytes);
+ return 1;
+@@ -190,11 +202,15 @@ int BN_bn2bin_padded(uint8_t *out, size_t len, const B
+ num_bytes = len;
+ }
+
+- // We only support little-endian platforms, so we can simply write the buffer
+- // in reverse.
++#ifdef OPENSSL_BIGENDIAN
+ for (size_t i = 0; i < num_bytes; i++) {
++ out[len - i - 1] = bytes[i ^ (BN_BYTES-1)];
++ }
++#else
++ for (size_t i = 0; i < num_bytes; i++) {
+ out[len - i - 1] = bytes[i];
+ }
++#endif
+ // Pad out the rest of the buffer with zeroes.
+ OPENSSL_memset(out, 0, len - num_bytes);
+ return 1;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_ecdsa_ecdsa.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_ecdsa_ecdsa.c
@@ -0,0 +1,14 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/ecdsa/ecdsa.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/ecdsa/ecdsa.c
+@@ -80,7 +80,11 @@ static void digest_to_scalar(const EC_GROUP *group, EC
+ }
+ OPENSSL_memset(out, 0, sizeof(EC_SCALAR));
+ for (size_t i = 0; i < digest_len; i++) {
++#ifdef OPENSSL_BIGENDIAN
++ out->bytes[i ^ (BN_BYTES-1)] = digest[digest_len - 1 - i];
++#else
+ out->bytes[i] = digest[digest_len - 1 - i];
++#endif
+ }
+
+ // If it is still too long, truncate remaining bits with a shift.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_gcm.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_gcm.c
@@ -0,0 +1,257 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/gcm.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/gcm.c
+@@ -78,6 +78,14 @@
+ } \
+ } while (0)
+
++#ifdef OPENSSL_BIGENDIAN
++#define GCM_bswap4(x) (x)
++#define GCM_bswap8(x) (x)
++#else
++#define GCM_bswap4 CRYPTO_bswap4
++#define GCM_bswap8 CRYPTO_bswap8
++#endif
++
+ // kSizeTWithoutLower4Bits is a mask that can be used to zero the lower four
+ // bits of a |size_t|.
+ static const size_t kSizeTWithoutLower4Bits = (size_t) -16;
+@@ -173,8 +181,8 @@ static void gcm_gmult_4bit(uint64_t Xi[2], const u128
+ Z.lo ^= Htable[nlo].lo;
+ }
+
+- Xi[0] = CRYPTO_bswap8(Z.hi);
+- Xi[1] = CRYPTO_bswap8(Z.lo);
++ Xi[0] = GCM_bswap8(Z.hi);
++ Xi[1] = GCM_bswap8(Z.lo);
+ }
+
+ // Streamed gcm_mult_4bit, see CRYPTO_gcm128_[en|de]crypt for
+@@ -233,8 +241,8 @@ static void gcm_ghash_4bit(uint64_t Xi[2], const u128
+ Z.lo ^= Htable[nlo].lo;
+ }
+
+- Xi[0] = CRYPTO_bswap8(Z.hi);
+- Xi[1] = CRYPTO_bswap8(Z.lo);
++ Xi[0] = GCM_bswap8(Z.hi);
++ Xi[1] = GCM_bswap8(Z.lo);
+ } while (inp += 16, len -= 16);
+ }
+ #else // GHASH_ASM
+@@ -360,8 +368,8 @@ void CRYPTO_ghash_init(gmult_func *out_mult, ghash_fun
+ OPENSSL_memcpy(H.c, gcm_key, 16);
+
+ // H is stored in host byte order
+- H.u[0] = CRYPTO_bswap8(H.u[0]);
+- H.u[1] = CRYPTO_bswap8(H.u[1]);
++ H.u[0] = GCM_bswap8(H.u[0]);
++ H.u[1] = GCM_bswap8(H.u[1]);
+
+ OPENSSL_memcpy(out_key, H.c, 16);
+
+@@ -474,15 +482,15 @@ void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const AE
+ GCM_MUL(ctx, Yi);
+ }
+ len0 <<= 3;
+- ctx->Yi.u[1] ^= CRYPTO_bswap8(len0);
++ ctx->Yi.u[1] ^= GCM_bswap8(len0);
+
+ GCM_MUL(ctx, Yi);
+- ctr = CRYPTO_bswap4(ctx->Yi.d[3]);
++ ctr = GCM_bswap4(ctx->Yi.d[3]);
+ }
+
+ (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EK0.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ }
+
+ int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const uint8_t *aad, size_t len) {
+@@ -580,7 +588,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ ctx->ares = 0;
+ }
+
+- ctr = CRYPTO_bswap4(ctx->Yi.d[3]);
++ ctr = GCM_bswap4(ctx->Yi.d[3]);
+
+ n = ctx->mres;
+ if (n) {
+@@ -602,7 +610,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ if (n == 0) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ }
+ ctx->Xi.c[n] ^= out[i] = in[i] ^ ctx->EKi.c[n];
+ n = (n + 1) % 16;
+@@ -621,7 +629,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ while (j) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ store_word_le(out + i,
+ load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]);
+@@ -638,7 +646,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ while (len >= 16) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ store_word_le(out + i,
+ load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]);
+@@ -653,7 +661,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ while (len >= 16) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ size_t tmp = load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)];
+ store_word_le(out + i, tmp);
+@@ -668,7 +676,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A
+ if (len) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ while (len--) {
+ ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
+ ++n;
+@@ -707,7 +715,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ ctx->ares = 0;
+ }
+
+- ctr = CRYPTO_bswap4(ctx->Yi.d[3]);
++ ctr = GCM_bswap4(ctx->Yi.d[3]);
+
+ n = ctx->mres;
+ if (n) {
+@@ -732,7 +740,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ if (n == 0) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ }
+ c = in[i];
+ out[i] = c ^ ctx->EKi.c[n];
+@@ -754,7 +762,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ while (j) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ store_word_le(out + i,
+ load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]);
+@@ -771,7 +779,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ while (len >= 16) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ store_word_le(out + i,
+ load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]);
+@@ -785,7 +793,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ while (len >= 16) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ for (size_t i = 0; i < 16; i += sizeof(size_t)) {
+ size_t c = load_word_le(in + i);
+ store_word_le(out + i, c ^ ctx->EKi.t[i / sizeof(size_t)]);
+@@ -800,7 +808,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A
+ if (len) {
+ (*block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ while (len--) {
+ uint8_t c = in[n];
+ ctx->Xi.c[n] ^= c;
+@@ -866,13 +874,13 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c
+ }
+ #endif
+
+- ctr = CRYPTO_bswap4(ctx->Yi.d[3]);
++ ctr = GCM_bswap4(ctx->Yi.d[3]);
+
+ #if defined(GHASH)
+ while (len >= GHASH_CHUNK) {
+ (*stream)(in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
+ ctr += GHASH_CHUNK / 16;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ GHASH(ctx, out, GHASH_CHUNK);
+ out += GHASH_CHUNK;
+ in += GHASH_CHUNK;
+@@ -885,7 +893,7 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c
+
+ (*stream)(in, out, j, key, ctx->Yi.c);
+ ctr += (unsigned int)j;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ in += i;
+ len -= i;
+ #if defined(GHASH)
+@@ -904,7 +912,7 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c
+ if (len) {
+ (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ while (len--) {
+ ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n];
+ ++n;
+@@ -970,14 +978,14 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c
+ }
+ #endif
+
+- ctr = CRYPTO_bswap4(ctx->Yi.d[3]);
++ ctr = GCM_bswap4(ctx->Yi.d[3]);
+
+ #if defined(GHASH)
+ while (len >= GHASH_CHUNK) {
+ GHASH(ctx, in, GHASH_CHUNK);
+ (*stream)(in, out, GHASH_CHUNK / 16, key, ctx->Yi.c);
+ ctr += GHASH_CHUNK / 16;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ out += GHASH_CHUNK;
+ in += GHASH_CHUNK;
+ len -= GHASH_CHUNK;
+@@ -1003,7 +1011,7 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c
+ #endif
+ (*stream)(in, out, j, key, ctx->Yi.c);
+ ctr += (unsigned int)j;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ out += i;
+ in += i;
+ len -= i;
+@@ -1011,7 +1019,7 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c
+ if (len) {
+ (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EKi.c, key);
+ ++ctr;
+- ctx->Yi.d[3] = CRYPTO_bswap4(ctr);
++ ctx->Yi.d[3] = GCM_bswap4(ctr);
+ while (len--) {
+ uint8_t c = in[n];
+ ctx->Xi.c[n] ^= c;
+@@ -1036,8 +1044,8 @@ int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const ui
+ GCM_MUL(ctx, Xi);
+ }
+
+- alen = CRYPTO_bswap8(alen);
+- clen = CRYPTO_bswap8(clen);
++ alen = GCM_bswap8(alen);
++ clen = GCM_bswap8(clen);
+
+ ctx->Xi.u[0] ^= alen;
+ ctx->Xi.u[1] ^= clen;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_internal.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_internal.h
@@ -0,0 +1,20 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h
+@@ -70,11 +70,17 @@ extern "C" {
+ static inline uint32_t GETU32(const void *in) {
+ uint32_t v;
+ OPENSSL_memcpy(&v, in, sizeof(v));
++#ifdef OPENSSL_BIGENDIAN
++ return v;
++#else
+ return CRYPTO_bswap4(v);
++#endif
+ }
+
+ static inline void PUTU32(void *out, uint32_t v) {
++#ifndef OPENSSL_BIGENDIAN
+ v = CRYPTO_bswap4(v);
++#endif
+ OPENSSL_memcpy(out, &v, sizeof(v));
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_polyval.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_polyval.c
@@ -0,0 +1,29 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/polyval.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/polyval.c
+@@ -32,16 +32,26 @@ static void byte_reverse(polyval_block *b) {
+ // the GHASH field, multiplies that by 'x' and serialises the result back into
+ // |b|, but with GHASH's backwards bit ordering.
+ static void reverse_and_mulX_ghash(polyval_block *b) {
++#ifdef OPENSSL_BIGENDIAN
++ uint64_t hi = CRYPTO_bswap8(b->u[0]);
++ uint64_t lo = CRYPTO_bswap8(b->u[1]);
++#else
+ uint64_t hi = b->u[0];
+ uint64_t lo = b->u[1];
++#endif
+ const crypto_word_t carry = constant_time_eq_w(hi & 1, 1);
+ hi >>= 1;
+ hi |= lo << 63;
+ lo >>= 1;
+ lo ^= ((uint64_t) constant_time_select_w(carry, 0xe1, 0)) << 56;
+
++#ifdef OPENSSL_BIGENDIAN
++ b->u[0] = lo;
++ b->u[1] = hi;
++#else
+ b->u[0] = CRYPTO_bswap8(lo);
+ b->u[1] = CRYPTO_bswap8(hi);
++#endif
+ }
+
+ // POLYVAL(H, X_1, ..., X_n) =
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_rand_ctrdrbg.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_rand_ctrdrbg.c
@@ -0,0 +1,15 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/rand/ctrdrbg.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/rand/ctrdrbg.c
+@@ -70,8 +70,12 @@ OPENSSL_STATIC_ASSERT(CTR_DRBG_ENTROPY_LEN % AES_BLOCK
+ // ctr_inc adds |n| to the last four bytes of |drbg->counter|, treated as a
+ // big-endian number.
+ static void ctr32_add(CTR_DRBG_STATE *drbg, uint32_t n) {
++#ifdef OPENSSL_BIGENDIAN
++ drbg->counter.words[3] += n;
++#else
+ drbg->counter.words[3] =
+ CRYPTO_bswap4(CRYPTO_bswap4(drbg->counter.words[3]) + n);
++#endif
+ }
+
+ static int ctr_drbg_update(CTR_DRBG_STATE *drbg, const uint8_t *data,
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_poly1305_poly1305.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_poly1305_poly1305.c
@@ -0,0 +1,19 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/crypto/poly1305/poly1305.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/poly1305/poly1305.c
+@@ -32,10 +32,16 @@
+ static uint32_t U8TO32_LE(const uint8_t *m) {
+ uint32_t r;
+ OPENSSL_memcpy(&r, m, sizeof(r));
++#ifdef OPENSSL_BIGENDIAN
++ r = CRYPTO_bswap4(r);
++#endif
+ return r;
+ }
+
+ static void U32TO8_LE(uint8_t *m, uint32_t v) {
++#ifdef OPENSSL_BIGENDIAN
++ v = CRYPTO_bswap4(v);
++#endif
+ OPENSSL_memcpy(m, &v, sizeof(v));
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_include_openssl_base.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_include_openssl_base.h
@@ -0,0 +1,17 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h 2019-10-29 11:49:25.706601000 +0100
+@@ -96,9 +96,13 @@
+ #elif defined(__arm) || defined(__arm__) || defined(_M_ARM)
+ #define OPENSSL_32_BIT
+ #define OPENSSL_ARM
+-#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(_LITTLE_ENDIAN)
++#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(__LITTLE_ENDIAN__)
+ #define OPENSSL_64_BIT
+ #define OPENSSL_PPC64LE
++#elif (defined(__PPC64__) || defined(__powerpc64__))
++#define OPENSSL_64_BIT
++#define OPENSSL_PPC64
++#define OPENSSL_BIGENDIAN
+ #elif defined(__mips__) && !defined(__LP64__)
+ #define OPENSSL_32_BIT
+ #define OPENSSL_MIPS
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_curve25519.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_curve25519.c
@@ -0,0 +1,19 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/curve25519.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/curve25519.c
+@@ -3032,9 +3032,14 @@ int ED25519_verify(const uint8_t *message, size_t mess
+ UINT64_C(0x1000000000000000),
+ };
+ for (size_t i = 3;; i--) {
+- if (scopy.u64[i] > kOrder[i]) {
++#ifdef OPENSSL_BIGENDIAN
++ const uint64_t n = CRYPTO_bswap8(scopy.u64[i]);
++#else
++ const uint64_t n = scopy.u64[i];
++#endif
++ if (n > kOrder[i]) {
+ return 0;
+- } else if (scopy.u64[i] < kOrder[i]) {
++ } else if (n < kOrder[i]) {
+ break;
+ } else if (i == 0) {
+ return 0;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_p256.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_p256.c
@@ -0,0 +1,51 @@
+--- src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/p256.c.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/p256.c
+@@ -882,12 +882,24 @@ static void fe_tobytes(uint8_t out[NBYTES], const fe i
+ }
+ }
+
++#ifdef OPENSSL_BIGENDIAN
++static void fe_tobytes_be(uint8_t out[NBYTES], const fe in) {
++ for (int i = 0; i<NBYTES; i++) {
++ out[i ^ (BN_BYTES-1)] = (uint8_t)(in[i/sizeof(in[0])] >> (8*(i%sizeof(in[0]))));
++ }
++}
++#endif
++
+ static void fe_frombytes(fe out, const uint8_t in[NBYTES]) {
+ for (int i = 0; i<NLIMBS; i++) {
+ out[i] = 0;
+ }
+ for (int i = 0; i<NBYTES; i++) {
++#ifdef OPENSSL_BIGENDIAN
++ out[i/sizeof(out[0])] |= ((limb_t)in[i ^ (BN_BYTES-1)]) << (8*(i%sizeof(out[0])));
++#else
+ out[i/sizeof(out[0])] |= ((limb_t)in[i]) << (8*(i%sizeof(out[0])));
++#endif
+ }
+ }
+
+@@ -906,7 +918,11 @@ static void fe_to_generic(EC_FELEM *out, const fe in)
+ OPENSSL_STATIC_ASSERT(
+ 256 / 8 == sizeof(BN_ULONG) * ((256 + BN_BITS2 - 1) / BN_BITS2),
+ "fe_tobytes leaves bytes uninitialized");
++#ifdef OPENSSL_BIGENDIAN
++ fe_tobytes_be(out->bytes, in);
++#else
+ fe_tobytes(out->bytes, in);
++#endif
+ }
+
+ // fe_inv calculates |out| = |in|^{-1}
+@@ -1524,7 +1540,11 @@ static char get_bit(const uint8_t *in, int i) {
+ if (i < 0 || i >= 256) {
+ return 0;
+ }
++#ifdef OPENSSL_BIGENDIAN
++ return (in[(i >> 3) ^ (sizeof(BN_ULONG)-1)] >> (i & 7)) & 1;
++#else
+ return (in[i >> 3] >> (i & 7)) & 1;
++#endif
+ }
+
+ // Interleaved point multiplication using precomputed point multiples: The
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_crc32c_BUILD.gn
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_crc32c_BUILD.gn
@@ -0,0 +1,16 @@
+--- src/3rdparty/chromium/third_party/crc32c/BUILD.gn.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/crc32c/BUILD.gn
+@@ -15,12 +15,9 @@ config("crc32c_config") {
+ ]
+
+ defines = [
+- "BYTE_ORDER_BIG_ENDIAN=0",
++ "BYTE_ORDER_BIG_ENDIAN=__BYTE_ORDER__==__ORDER_BIG_ENDIAN__",
+ "CRC32C_TESTS_BUILT_WITH_GLOG=0",
+ ]
+-
+- # If we ever support big-endian builds, add logic to conditionally enable
+- # BYTE_ORDER_BIG_ENDIAN.
+
+ if (target_cpu == "x86" || target_cpu == "x64") {
+ defines += [
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_base.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_base.h
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/base.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/base.h
+@@ -220,18 +220,15 @@ template<typename T> T EndianSwap(T t) {
+ if (sizeof(T) == 1) { // Compile-time if-then's.
+ return t;
+ } else if (sizeof(T) == 2) {
+- union { T t; uint16_t i; } u;
+- u.t = t;
++ union U { T t; uint16_t i; U(const T& t_) : t(t_) {}} u(t);
+ u.i = FLATBUFFERS_BYTESWAP16(u.i);
+ return u.t;
+ } else if (sizeof(T) == 4) {
+- union { T t; uint32_t i; } u;
+- u.t = t;
++ union U { T t; uint32_t i; U(const T& t_) : t(t_) {}} u(t);
+ u.i = FLATBUFFERS_BYTESWAP32(u.i);
+ return u.t;
+ } else if (sizeof(T) == 8) {
+- union { T t; uint64_t i; } u;
+- u.t = t;
++ union U { T t; uint64_t i; U(const T& t_) : t(t_) {}} u(t);
+ u.i = FLATBUFFERS_BYTESWAP64(u.i);
+ return u.t;
+ } else {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_minireflect.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_minireflect.h
@@ -0,0 +1,73 @@
+--- src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/minireflect.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/minireflect.h
+@@ -122,58 +122,58 @@ inline void IterateValue(ElementaryType type, const ui
+ soffset_t vector_index, IterationVisitor *visitor) {
+ switch (type) {
+ case ET_UTYPE: {
+- auto tval = *reinterpret_cast<const uint8_t *>(val);
++ auto tval = ReadScalar<uint8_t>(val);
+ visitor->UType(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_BOOL: {
+- visitor->Bool(*reinterpret_cast<const uint8_t *>(val) != 0);
++ visitor->Bool(ReadScalar<uint8_t>(val) != 0);
+ break;
+ }
+ case ET_CHAR: {
+- auto tval = *reinterpret_cast<const int8_t *>(val);
++ auto tval = ReadScalar<int8_t>(val);
+ visitor->Char(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_UCHAR: {
+- auto tval = *reinterpret_cast<const uint8_t *>(val);
++ auto tval = ReadScalar<uint8_t>(val);
+ visitor->UChar(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_SHORT: {
+- auto tval = *reinterpret_cast<const int16_t *>(val);
++ auto tval = ReadScalar<int16_t>(val);
+ visitor->Short(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_USHORT: {
+- auto tval = *reinterpret_cast<const uint16_t *>(val);
++ auto tval = ReadScalar<uint16_t>(val);
+ visitor->UShort(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_INT: {
+- auto tval = *reinterpret_cast<const int32_t *>(val);
++ auto tval = ReadScalar<int32_t>(val);
+ visitor->Int(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_UINT: {
+- auto tval = *reinterpret_cast<const uint32_t *>(val);
++ auto tval = ReadScalar<uint32_t>(val);
+ visitor->UInt(tval, EnumName(tval, type_table));
+ break;
+ }
+ case ET_LONG: {
+- visitor->Long(*reinterpret_cast<const int64_t *>(val));
++ visitor->Long(ReadScalar<int64_t>(val));
+ break;
+ }
+ case ET_ULONG: {
+- visitor->ULong(*reinterpret_cast<const uint64_t *>(val));
++ visitor->ULong(ReadScalar<uint64_t>(val));
+ break;
+ }
+ case ET_FLOAT: {
+- visitor->Float(*reinterpret_cast<const float *>(val));
++ visitor->Float(ReadScalar<float>(val));
+ break;
+ }
+ case ET_DOUBLE: {
+- visitor->Double(*reinterpret_cast<const double *>(val));
++ visitor->Double(ReadScalar<double>(val));
+ break;
+ }
+ case ET_STRING: {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_leveldatabase_port_port__chromium.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_leveldatabase_port_port__chromium.h
@@ -0,0 +1,15 @@
+--- src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h
+@@ -23,8 +23,11 @@
+ namespace leveldb {
+ namespace port {
+
+-// Chromium only supports little endian.
++#if ARCH_CPU_LITTLE_ENDIAN
+ static const bool kLittleEndian = true;
++#else
++static const bool kLittleEndian = false;
++#endif
+
+ class LOCKABLE Mutex {
+ public:
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_BUILD.gn
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_BUILD.gn
@@ -0,0 +1,14 @@
+--- src/3rdparty/chromium/third_party/libpng/BUILD.gn.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/libpng/BUILD.gn
+@@ -93,6 +93,11 @@ source_set("libpng_sources") {
+ "mips/filter_msa_intrinsics.c",
+ "mips/mips_init.c",
+ ]
++ } else if (current_cpu == "ppc64") {
++ sources += [
++ "powerpc/filter_vsx_intrinsics.c",
++ "powerpc/powerpc_init.c",
++ ]
+ }
+
+ configs -= [ "//build/config/compiler:chromium_code" ]
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_filter__vsx__intrinsics.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_filter__vsx__intrinsics.c
@@ -0,0 +1,770 @@
+--- src/3rdparty/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c.orig 2019-10-27 17:23:52 UTC
++++ src/3rdparty/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c
+@@ -0,0 +1,767 @@
++/* filter_vsx_intrinsics.c - PowerPC optimised filter functions
++ *
++ * Copyright (c) 2017 Glenn Randers-Pehrson
++ * Written by Vadim Barkov, 2017.
++ * Last changed in libpng 1.6.29 [March 16, 2017]
++ *
++ * This code is released under the libpng license.
++ * For conditions of distribution and use, see the disclaimer
++ * and license in png.h
++ */
++#include <stdio.h>
++#include <stdint.h>
++#include "../pngpriv.h"
++
++#ifdef PNG_READ_SUPPORTED
++
++/* This code requires -maltivec and -mvsx on the command line: */
++#if PNG_POWERPC_VSX_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */
++
++#include <altivec.h>
++
++#if PNG_POWERPC_VSX_OPT > 0
++
++#ifndef __VSX__
++# error "This code requires VSX support (POWER7 and later). Please provide -mvsx compiler flag."
++#endif
++
++#define vec_ld_unaligned(vec,data) vec = vec_vsx_ld(0,data)
++#define vec_st_unaligned(vec,data) vec_vsx_st(vec,0,data)
++
++
++/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d).
++ * They're positioned like this:
++ * prev: c b
++ * row: a d
++ * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be
++ * whichever of a, b, or c is closest to p=a+b-c.
++ * ( this is taken from ../intel/filter_sse2_intrinsics.c )
++ */
++
++#define vsx_declare_common_vars(row_info,row,prev_row,offset) \
++ png_byte i;\
++ png_bytep rp = row + offset;\
++ png_const_bytep pp = prev_row;\
++ png_size_t unaligned_top = 16 - (((png_size_t)rp % 16));\
++ png_size_t istop;\
++ if(unaligned_top == 16)\
++ unaligned_top = 0;\
++ istop = row_info->rowbytes;\
++ if((unaligned_top < istop))\
++ istop -= unaligned_top;\
++ else{\
++ unaligned_top = istop;\
++ istop = 0;\
++ }
++
++void png_read_filter_row_up_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ vector unsigned char rp_vec;
++ vector unsigned char pp_vec;
++ vsx_declare_common_vars(row_info,row,prev_row,0)
++
++ /* Altivec operations require 16-byte aligned data
++ * but input can be unaligned. So we calculate
++ * unaligned part as usual.
++ */
++ for (i = 0; i < unaligned_top; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
++ rp++;
++ }
++
++ /* Using SIMD while we can */
++ while( istop >= 16 )
++ {
++ rp_vec = vec_ld(0,rp);
++ vec_ld_unaligned(pp_vec,pp);
++
++ rp_vec = vec_add(rp_vec,pp_vec);
++
++ vec_st(rp_vec,0,rp);
++
++ pp += 16;
++ rp += 16;
++ istop -= 16;
++ }
++
++ if(istop > 0)
++ {
++ /* If byte count of row is not divisible by 16
++ * we will process remaining part as usual
++ */
++ for (i = 0; i < istop; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff);
++ rp++;
++ }
++}
++
++}
++
++static const vector unsigned char VSX_LEFTSHIFTED1_4 = {16,16,16,16, 0, 1, 2, 3,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_LEFTSHIFTED2_4 = {16,16,16,16,16,16,16,16, 4, 5, 6, 7,16,16,16,16};
++static const vector unsigned char VSX_LEFTSHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 8, 9,10,11};
++
++static const vector unsigned char VSX_LEFTSHIFTED1_3 = {16,16,16, 0, 1, 2,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_LEFTSHIFTED2_3 = {16,16,16,16,16,16, 3, 4, 5,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_LEFTSHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 6, 7, 8,16,16,16,16};
++static const vector unsigned char VSX_LEFTSHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 9,10,11,16};
++
++static const vector unsigned char VSX_NOT_SHIFTED1_4 = {16,16,16,16, 4, 5, 6, 7,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_NOT_SHIFTED2_4 = {16,16,16,16,16,16,16,16, 8, 9,10,11,16,16,16,16};
++static const vector unsigned char VSX_NOT_SHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,15};
++
++static const vector unsigned char VSX_NOT_SHIFTED1_3 = {16,16,16, 3, 4, 5,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_NOT_SHIFTED2_3 = {16,16,16,16,16,16, 6, 7, 8,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_NOT_SHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 9,10,11,16,16,16,16};
++static const vector unsigned char VSX_NOT_SHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,16};
++
++static const vector unsigned char VSX_CHAR_ZERO = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
++#ifdef __LITTLE_ENDIAN__
++
++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = { 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = { 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {12,16,13,16,14,16,15,16,16,16,16,16,16,16,16,16};
++
++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 0, 2, 4, 6,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 0, 2, 4, 6,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4, 6};
++
++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = { 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = { 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = { 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {12,16,13,16,14,16,16,16,16,16,16,16,16,16,16,16};
++
++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 0, 2, 4,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 0, 2, 4,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 0, 2, 4,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4,16};
++
++#elif defined(__BIG_ENDIAN__)
++
++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = {16, 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = {16, 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {16,12,16,13,16,14,16,15,16,16,16,16,16,16,16,16};
++
++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 1, 3, 5, 7,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 1, 3, 5, 7,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5, 7};
++
++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = {16, 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = {16, 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = {16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {16,12,16,13,16,14,16,16,16,16,16,16,16,16,16,16};
++
++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 1, 3, 5,16,16,16,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 1, 3, 5,16,16,16,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 1, 3, 5,16,16,16,16};
++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5,16};
++
++#endif
++
++#define vsx_char_to_short(vec,offset,bpp) (vector unsigned short)vec_perm((vec),VSX_CHAR_ZERO,VSX_CHAR_TO_SHORT##offset##_##bpp)
++#define vsx_short_to_char(vec,offset,bpp) vec_perm(((vector unsigned char)(vec)),VSX_CHAR_ZERO,VSX_SHORT_TO_CHAR##offset##_##bpp)
++
++#ifdef PNG_USE_ABS
++# define vsx_abs(number) abs(number)
++#else
++# define vsx_abs(number) (number > 0) ? (number) : -(number)
++#endif
++
++void png_read_filter_row_sub4_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 4;
++
++ vector unsigned char rp_vec;
++ vector unsigned char part_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++
++ PNG_UNUSED(pp)
++
++ /* Altivec operations require 16-byte aligned data
++ * but input can be unaligned. So we calculate
++ * unaligned part as usual.
++ */
++ for (i = 0; i < unaligned_top; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++
++ /* Using SIMD while we can */
++ while( istop >= 16 )
++ {
++ for(i=0;i < bpp ; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++ rp -= bpp;
++
++ rp_vec = vec_ld(0,rp);
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ vec_st(rp_vec,0,rp);
++
++ rp += 16;
++ istop -= 16;
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp - bpp))) & 0xff);
++ rp++;
++ }
++
++}
++
++void png_read_filter_row_sub3_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 3;
++
++ vector unsigned char rp_vec;
++ vector unsigned char part_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++
++ PNG_UNUSED(pp)
++
++ /* Altivec operations require 16-byte aligned data
++ * but input can be unaligned. So we calculate
++ * unaligned part as usual.
++ */
++ for (i = 0; i < unaligned_top; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++
++ /* Using SIMD while we can */
++ while( istop >= 16 )
++ {
++ for(i=0;i < bpp ; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++ rp -= bpp;
++
++ rp_vec = vec_ld(0,rp);
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3);
++ rp_vec = vec_add(rp_vec,part_vec);
++
++ vec_st(rp_vec,0,rp);
++ rp += 15;
++ istop -= 16;
++
++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must
++ * be proceeded manually
++ */
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff);
++ rp++;
++ }
++}
++
++void png_read_filter_row_avg4_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 4;
++
++ vector unsigned char rp_vec;
++ vector unsigned char pp_vec;
++ vector unsigned char pp_part_vec;
++ vector unsigned char rp_part_vec;
++ vector unsigned char avg_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++ rp -= bpp;
++ if(istop >= bpp)
++ istop -= bpp;
++
++ for (i = 0; i < bpp; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ ((int)(*pp++) / 2 )) & 0xff);
++
++ rp++;
++ }
++
++ /* Altivec operations require 16-byte aligned data
++ * but input can be unaligned. So we calculate
++ * unaligned part as usual.
++ */
++ for (i = 0; i < unaligned_top; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++
++ /* Using SIMD while we can */
++ while( istop >= 16 )
++ {
++ for(i=0;i < bpp ; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++ rp -= bpp;
++ pp -= bpp;
++
++ vec_ld_unaligned(pp_vec,pp);
++ rp_vec = vec_ld(0,rp);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_4);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_4);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_4);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ vec_st(rp_vec,0,rp);
++
++ rp += 16;
++ pp += 16;
++ istop -= 16;
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++}
++
++void png_read_filter_row_avg3_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 3;
++
++ vector unsigned char rp_vec;
++ vector unsigned char pp_vec;
++ vector unsigned char pp_part_vec;
++ vector unsigned char rp_part_vec;
++ vector unsigned char avg_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++ rp -= bpp;
++ if(istop >= bpp)
++ istop -= bpp;
++
++ for (i = 0; i < bpp; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ ((int)(*pp++) / 2 )) & 0xff);
++
++ rp++;
++ }
++
++ /* Altivec operations require 16-byte aligned data
++ * but input can be unaligned. So we calculate
++ * unaligned part as usual.
++ */
++ for (i = 0; i < unaligned_top; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++
++ /* Using SIMD while we can */
++ while( istop >= 16 )
++ {
++ for(i=0;i < bpp ; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++ rp -= bpp;
++ pp -= bpp;
++
++ vec_ld_unaligned(pp_vec,pp);
++ rp_vec = vec_ld(0,rp);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_3);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_3);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_3);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3);
++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED4_3);
++ avg_vec = vec_avg(rp_part_vec,pp_part_vec);
++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1)));
++ rp_vec = vec_add(rp_vec,avg_vec);
++
++ vec_st(rp_vec,0,rp);
++
++ rp += 15;
++ pp += 15;
++ istop -= 16;
++
++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must
++ * be proceeded manually
++ */
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++ rp++;
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ *rp = (png_byte)(((int)(*rp) +
++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff);
++
++ rp++;
++ }
++}
++
++/* Bytewise c ? t : e. */
++#define if_then_else(c,t,e) vec_sel(e,t,c)
++
++#define vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) {\
++ c = *(pp - bpp);\
++ a = *(rp - bpp);\
++ b = *pp++;\
++ p = b - c;\
++ pc = a - c;\
++ pa = vsx_abs(p);\
++ pb = vsx_abs(pc);\
++ pc = vsx_abs(p + pc);\
++ if (pb < pa) pa = pb, a = b;\
++ if (pc < pa) a = c;\
++ a += *rp;\
++ *rp++ = (png_byte)a;\
++ }
++
++void png_read_filter_row_paeth4_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 4;
++
++ int a, b, c, pa, pb, pc, p;
++ vector unsigned char rp_vec;
++ vector unsigned char pp_vec;
++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec;
++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++ rp -= bpp;
++ if(istop >= bpp)
++ istop -= bpp;
++
++ /* Process the first pixel in the row completely (this is the same as 'up'
++ * because there is only one candidate predictor for the first row).
++ */
++ for(i = 0; i < bpp ; i++)
++ {
++ *rp = (png_byte)( *rp + *pp);
++ rp++;
++ pp++;
++ }
++
++ for(i = 0; i < unaligned_top ; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++
++ while( istop >= 16)
++ {
++ for(i = 0; i < bpp ; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++
++ rp -= bpp;
++ pp -= bpp;
++ rp_vec = vec_ld(0,rp);
++ vec_ld_unaligned(pp_vec,pp);
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_4),1,4);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,4)));
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_4),2,4);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,4)));
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_4),3,4);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,4)));
++
++ vec_st(rp_vec,0,rp);
++
++ rp += 16;
++ pp += 16;
++ istop -= 16;
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++}
++
++void png_read_filter_row_paeth3_vsx(png_row_infop row_info, png_bytep row,
++ png_const_bytep prev_row)
++{
++ const png_byte bpp = 3;
++
++ int a, b, c, pa, pb, pc, p;
++ vector unsigned char rp_vec;
++ vector unsigned char pp_vec;
++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec;
++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec;
++
++ vsx_declare_common_vars(row_info,row,prev_row,bpp)
++ rp -= bpp;
++ if(istop >= bpp)
++ istop -= bpp;
++
++ /* Process the first pixel in the row completely (this is the same as 'up'
++ * because there is only one candidate predictor for the first row).
++ */
++ for(i = 0; i < bpp ; i++)
++ {
++ *rp = (png_byte)( *rp + *pp);
++ rp++;
++ pp++;
++ }
++
++ for(i = 0; i < unaligned_top ; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++
++ while( istop >= 16)
++ {
++ for(i = 0; i < bpp ; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++
++ rp -= bpp;
++ pp -= bpp;
++ rp_vec = vec_ld(0,rp);
++ vec_ld_unaligned(pp_vec,pp);
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_3),1,3);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,3)));
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_3),2,3);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,3)));
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_3),3,3);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,3)));
++
++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3);
++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED4_3),4,3);
++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3);
++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec);
++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec);
++ pc_vec = vec_add(pa_vec,pb_vec);
++ pa_vec = vec_abs(pa_vec);
++ pb_vec = vec_abs(pb_vec);
++ pc_vec = vec_abs(pc_vec);
++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec));
++ nearest_vec = if_then_else(
++ vec_cmpeq(pa_vec,smallest_vec),
++ a_vec,
++ if_then_else(
++ vec_cmpeq(pb_vec,smallest_vec),
++ b_vec,
++ c_vec
++ )
++ );
++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,4,3)));
++
++ vec_st(rp_vec,0,rp);
++
++ rp += 15;
++ pp += 15;
++ istop -= 16;
++
++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must
++ * be proceeded manually
++ */
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++
++ if(istop > 0)
++ for (i = 0; i < istop % 16; i++)
++ {
++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp)
++ }
++}
++
++#endif /* PNG_POWERPC_VSX_OPT > 0 */
++#endif /* PNG_POWERPC_VSX_IMPLEMENTATION == 1 (intrinsics) */
++#endif /* READ */
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_powerpc__init.c
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_powerpc__init.c
@@ -0,0 +1,128 @@
+--- src/3rdparty/chromium/third_party/libpng/powerpc/powerpc_init.c.orig 2019-10-27 17:23:52 UTC
++++ src/3rdparty/chromium/third_party/libpng/powerpc/powerpc_init.c
+@@ -0,0 +1,125 @@
++
++/* powerpc_init.c - POWERPC optimised filter functions
++ *
++ * Copyright (c) 2017 Glenn Randers-Pehrson
++ * Written by Vadim Barkov, 2017.
++ * Last changed in libpng 1.6.29 [March 16, 2017]
++ *
++ * This code is released under the libpng license.
++ * For conditions of distribution and use, see the disclaimer
++ * and license in png.h
++ */
++/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are
++ * called.
++ */
++#define _POSIX_SOURCE 1
++
++#include <stdio.h>
++#include "../pngpriv.h"
++
++#ifdef PNG_READ_SUPPORTED
++
++#if PNG_POWERPC_VSX_OPT > 0
++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED /* Do run-time checks */
++/* WARNING: it is strongly recommended that you do not build libpng with
++ * run-time checks for CPU features if at all possible. In the case of the PowerPC
++ * VSX instructions there is no processor-specific way of detecting the
++ * presence of the required support, therefore run-time detection is extremely
++ * OS specific.
++ *
++ * You may set the macro PNG_POWERPC_VSX_FILE to the file name of file containing
++ * a fragment of C source code which defines the png_have_vsx function. There
++ * are a number of implementations in contrib/powerpc-vsx, but the only one that
++ * has partial support is contrib/powerpc-vsx/linux.c - a generic Linux
++ * implementation which reads /proc/cpufino.
++ */
++#ifndef PNG_POWERPC_VSX_FILE
++# ifdef __linux__
++# define PNG_POWERPC_VSX_FILE "contrib/powerpc-vsx/linux_aux.c"
++# endif
++#endif
++
++#ifdef PNG_POWERPC_VSX_FILE
++
++#include <signal.h> /* for sig_atomic_t */
++static int png_have_vsx(png_structp png_ptr);
++#include PNG_POWERPC_VSX_FILE
++
++#else /* PNG_POWERPC_VSX_FILE */
++# error "PNG_POWERPC_VSX_FILE undefined: no support for run-time POWERPC VSX checks"
++#endif /* PNG_POWERPC_VSX_FILE */
++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */
++
++void
++png_init_filter_functions_vsx(png_structp pp, unsigned int bpp)
++{
++ /* The switch statement is compiled in for POWERPC_VSX_API, the call to
++ * png_have_vsx is compiled in for POWERPC_VSX_CHECK. If both are defined
++ * the check is only performed if the API has not set the PowerPC option on
++ * or off explicitly. In this case the check controls what happens.
++ */
++
++#ifdef PNG_POWERPC_VSX_API_SUPPORTED
++ switch ((pp->options >> PNG_POWERPC_VSX) & 3)
++ {
++ case PNG_OPTION_UNSET:
++ /* Allow the run-time check to execute if it has been enabled -
++ * thus both API and CHECK can be turned on. If it isn't supported
++ * this case will fall through to the 'default' below, which just
++ * returns.
++ */
++#endif /* PNG_POWERPC_VSX_API_SUPPORTED */
++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED
++ {
++ static volatile sig_atomic_t no_vsx = -1; /* not checked */
++
++ if (no_vsx < 0)
++ no_vsx = !png_have_vsx(pp);
++
++ if (no_vsx)
++ return;
++ }
++#ifdef PNG_POWERPC_VSX_API_SUPPORTED
++ break;
++#endif
++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */
++
++#ifdef PNG_POWERPC_VSX_API_SUPPORTED
++ default: /* OFF or INVALID */
++ return;
++
++ case PNG_OPTION_ON:
++ /* Option turned on */
++ break;
++ }
++#endif
++
++ /* IMPORTANT: any new internal functions used here must be declared using
++ * PNG_INTERNAL_FUNCTION in ../pngpriv.h. This is required so that the
++ * 'prefix' option to configure works:
++ *
++ * ./configure --with-libpng-prefix=foobar_
++ *
++ * Verify you have got this right by running the above command, doing a build
++ * and examining pngprefix.h; it must contain a #define for every external
++ * function you add. (Notice that this happens automatically for the
++ * initialization function.)
++ */
++ pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_vsx;
++
++ if (bpp == 3)
++ {
++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_vsx;
++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_vsx;
++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_vsx;
++ }
++
++ else if (bpp == 4)
++ {
++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_vsx;
++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_vsx;
++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_vsx;
++ }
++}
++#endif /* PNG_POWERPC_VSX_OPT > 0 */
++#endif /* READ */
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_BUILD.gn
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_BUILD.gn
@@ -0,0 +1,19 @@
+--- src/3rdparty/chromium/third_party/modp_b64/BUILD.gn.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/modp_b64/BUILD.gn
+@@ -2,10 +2,16 @@
+ # Use of this source code is governed by a BSD-style license that can be
+ # found in the LICENSE file.
+
++import("//build/config/host_byteorder.gni")
++
+ static_library("modp_b64") {
+ sources = [
+ "modp_b64.cc",
+ "modp_b64.h",
+ "modp_b64_data.h",
+ ]
++
++ if (host_byteorder == "big") {
++ defines = [ "WORDS_BIGENDIAN=1" ]
++ }
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_modp__b64.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_modp__b64.cc
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc
+@@ -118,7 +118,7 @@ size_t modp_b64_encode(char* dest, const char* str, si
+ }
+
+ #ifdef WORDS_BIGENDIAN /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
+-int modp_b64_decode(char* dest, const char* src, int len)
++size_t modp_b64_decode(char* dest, const char* src, size_t len)
+ {
+ if (len == 0) return 0;
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_pdfium_third__party_base_allocator_partition__allocator_page__allocator__constants.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_pdfium_third__party_base_allocator_partition__allocator_page__allocator__constants.h
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h 2019-10-29 15:25:35.191867000 +0100
+@@ -13,7 +13,7 @@
+ namespace base {
+ #if defined(OS_WIN)
+ static constexpr size_t kPageAllocationGranularityShift = 16; // 64KB
+-#elif defined(_MIPS_ARCH_LOONGSON)
++#elif defined(_MIPS_ARCH_LOONGSON) || defined(ARCH_CPU_PPC64)
+ static constexpr size_t kPageAllocationGranularityShift = 14; // 16KB
+ #else
+ static constexpr size_t kPageAllocationGranularityShift = 12; // 4KB
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_base_utils.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_base_utils.h
@@ -0,0 +1,19 @@
+--- src/3rdparty/chromium/third_party/perfetto/include/perfetto/base/utils.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/perfetto/include/perfetto/base/utils.h
+@@ -22,6 +22,7 @@
+ #include <errno.h>
+ #include <stddef.h>
+ #include <stdlib.h>
++#include <type_traits>
+ #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
+ #include <sys/types.h>
+ #endif
+@@ -91,7 +92,7 @@ struct FreeDeleter {
+
+ template <typename T>
+ constexpr T AssumeLittleEndian(T value) {
+- static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__,
++ static_assert(std::is_same<T,T>::value && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__,
+ "Unimplemented on big-endian archs");
+ return value;
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_protozero_message.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_protozero_message.h
@@ -0,0 +1,16 @@
+--- src/3rdparty/chromium/third_party/perfetto/include/perfetto/protozero/message.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/perfetto/include/perfetto/protozero/message.h
+@@ -138,6 +138,13 @@ class PERFETTO_EXPORT Message {
+
+ pos = proto_utils::WriteVarInt(proto_utils::MakeTagFixed<T>(field_id), pos);
+ memcpy(pos, &value, sizeof(T));
++#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
++ for (size_t i = sizeof(T)/2; i--; ) {
++ uint8_t tmp = pos[i];
++ pos[i] = pos[sizeof(T)-1-i];
++ pos[sizeof(T)-1-i] = tmp;
++ }
++#endif
+ pos += sizeof(T);
+ // TODO: Optimize memcpy performance, see http://crbug.com/624311 .
+ WriteToStream(buffer, pos);
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_message.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_message.cc
@@ -0,0 +1,15 @@
+--- src/3rdparty/chromium/third_party/perfetto/src/protozero/message.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/perfetto/src/protozero/message.cc
+@@ -21,12 +21,6 @@
+ #include "perfetto/base/logging.h"
+ #include "perfetto/protozero/message_handle.h"
+
+-#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__
+-// The memcpy() for float and double below needs to be adjusted if we want to
+-// support big endian CPUs. There doesn't seem to be a compelling need today.
+-#error Unimplemented for big endian archs.
+-#endif
+-
+ namespace protozero {
+
+ // static
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_proto__decoder.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_proto__decoder.cc
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/third_party/perfetto/src/protozero/proto_decoder.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/perfetto/src/protozero/proto_decoder.cc
+@@ -29,7 +29,8 @@ using namespace proto_utils;
+ #define BYTE_SWAP_TO_LE32(x) (x)
+ #define BYTE_SWAP_TO_LE64(x) (x)
+ #else
+-#error Unimplemented for big endian archs.
++#define BYTE_SWAP_TO_LE32(x) __builtin_bswap32(x)
++#define BYTE_SWAP_TO_LE64(x) __builtin_bswap64(x)
+ #endif
+
+ ProtoDecoder::Field ProtoDecoder::ReadField() {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_core_SkPostConfig.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_core_SkPostConfig.h
@@ -0,0 +1,15 @@
+--- src/3rdparty/chromium/third_party/skia/include/core/SkPostConfig.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/include/core/SkPostConfig.h
+@@ -40,12 +40,6 @@
+ # error "must define either SK_CPU_LENDIAN or SK_CPU_BENDIAN"
+ #endif
+
+-#if defined(SK_CPU_BENDIAN) && !defined(I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN)
+- #error "The Skia team is not endian-savvy enough to support big-endian CPUs."
+- #error "If you still want to use Skia,"
+- #error "please define I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN."
+-#endif
+-
+ /**
+ * Ensure the port has defined all of SK_X32_SHIFT, or none of them.
+ */
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_private_GrTypesPriv.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_private_GrTypesPriv.h
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/third_party/skia/include/private/GrTypesPriv.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/include/private/GrTypesPriv.h
+@@ -65,9 +65,6 @@ enum GrPixelConfig {
+ static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
+
+ // Aliases for pixel configs that match skia's byte order.
+-#ifndef SK_CPU_LENDIAN
+-#error "Skia gpu currently assumes little endian"
+-#endif
+ #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
+ static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
+ #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_codec_SkCodecPriv.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_codec_SkCodecPriv.h
@@ -0,0 +1,10 @@
+--- src/3rdparty/chromium/third_party/skia/src/codec/SkCodecPriv.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/codec/SkCodecPriv.h
+@@ -14,6 +14,7 @@
+ #include "SkEncodedOrigin.h"
+ #include "SkImageInfo.h"
+ #include "SkTypes.h"
++#include "SkEndian.h"
+
+ #ifdef SK_PRINT_CODEC_MESSAGES
+ #define SkCodecPrintf SkDebugf
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkColor.cpp
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkColor.cpp
@@ -0,0 +1,34 @@
+--- src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp
+@@ -108,13 +108,29 @@ SkColor SkHSVToColor(U8CPU a, const SkScalar hsv[3]) {
+ template <>
+ SkColor4f SkColor4f::FromColor(SkColor bgra) {
+ SkColor4f rgba;
+- swizzle_rb(Sk4f_fromL32(bgra)).store(rgba.vec());
++ Sk4f c4f = Sk4f_fromL32(bgra);
++#ifdef SK_CPU_BENDIAN
++ // ARGB -> RGBA
++ c4f = SkNx_shuffle<1, 2, 3, 0>(c4f);
++#else
++ // BGRA -> RGBA
++ c4f = swizzle_rb(c4f);
++#endif
++ c4f.store(rgba.vec());
+ return rgba;
+ }
+
+ template <>
+ SkColor SkColor4f::toSkColor() const {
+- return Sk4f_toL32(swizzle_rb(Sk4f::Load(this->vec())));
++ Sk4f c4f = Sk4f::Load(this->vec());
++#ifdef SK_CPU_BENDIAN
++ // RGBA -> ARGB
++ c4f = SkNx_shuffle<3, 0, 1, 2>(c4f);
++#else
++ // RGBA -> BGRA
++ c4f = swizzle_rb(c4f);
++#endif
++ return Sk4f_toL32(c4f);
+ }
+
+ template <>
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkPixmap.cpp
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkPixmap.cpp
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp
+@@ -246,7 +246,8 @@ SkColor SkPixmap::getColor(int x, int y) const {
+ const bool needsUnpremul = (kPremul_SkAlphaType == fInfo.alphaType());
+ auto toColor = [needsUnpremul](uint32_t maybePremulColor) {
+ return needsUnpremul ? SkUnPreMultiply::PMColorToColor(maybePremulColor)
+- : SkSwizzle_BGRA_to_PMColor(maybePremulColor);
++ : SkColorSetARGB(SkGetPackedA32(maybePremulColor), SkGetPackedR32(maybePremulColor),
++ SkGetPackedG32(maybePremulColor), SkGetPackedB32(maybePremulColor));
+ };
+
+ switch (this->colorType()) {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_Sk4px__none.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_Sk4px__none.h
@@ -0,0 +1,10 @@
+--- src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h
+@@ -35,7 +35,6 @@ inline Sk4px Sk4px::Wide::div255() const {
+ }
+
+ inline Sk4px Sk4px::alphas() const {
+- static_assert(SK_A32_SHIFT == 24, "This method assumes little-endian.");
+ return Sk16b((*this)[ 3], (*this)[ 3], (*this)[ 3], (*this)[ 3],
+ (*this)[ 7], (*this)[ 7], (*this)[ 7], (*this)[ 7],
+ (*this)[11], (*this)[11], (*this)[11], (*this)[11],
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkBlitRow__opts.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkBlitRow__opts.h
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h
+@@ -237,8 +237,8 @@ void blit_row_s32a_opaque(SkPMColor* dst, const SkPMCo
+ // with chromium:611002 we need to keep it until we figure out where
+ // the non-premultiplied src values (like 0x00FFFFFF) are coming from.
+ // TODO(mtklein): sort this out and assert *src is premul here.
+- if (*src & 0xFF000000) {
+- *dst = (*src >= 0xFF000000) ? *src : SkPMSrcOver(*src, *dst);
++ if (*src & (0xFF << SK_A32_SHIFT)) {
++ *dst = ((*src << (24 - SK_A32_SHIFT)) >= 0xFF000000) ? *src : SkPMSrcOver(*src, *dst);
+ }
+ src++;
+ dst++;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h
@@ -1,4 +1,4 @@
---- src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h.orig 2019-05-23 12:39:34 UTC
+--- src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h.orig 2019-10-27 17:19:53 UTC
+++ src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h
@@ -729,7 +729,10 @@ SI F approx_powf(F x, F y) {
}
@@ -24,3 +24,107 @@
__fp16 fp16 = __fp16(f);
U16 u16;
memcpy(&u16, &fp16, sizeof(U16));
+@@ -954,10 +954,17 @@ SI void from_4444(U16 _4444, F* r, F* g, F* b, F* a) {
+ *a = cast(wide & (15<< 0)) * (1.0f / (15<< 0));
+ }
+ SI void from_8888(U32 _8888, F* r, F* g, F* b, F* a) {
++#ifdef SK_CPU_BENDIAN
++ *r = cast((_8888 >> 24) ) * (1/255.0f);
++ *g = cast((_8888 >> 16) & 0xff) * (1/255.0f);
++ *b = cast((_8888 >> 8) & 0xff) * (1/255.0f);
++ *a = cast((_8888 ) & 0xff) * (1/255.0f);
++#else
+ *r = cast((_8888 ) & 0xff) * (1/255.0f);
+ *g = cast((_8888 >> 8) & 0xff) * (1/255.0f);
+ *b = cast((_8888 >> 16) & 0xff) * (1/255.0f);
+ *a = cast((_8888 >> 24) ) * (1/255.0f);
++#endif
+ }
+ SI void from_1010102(U32 rgba, F* r, F* g, F* b, F* a) {
+ *r = cast((rgba ) & 0x3ff) * (1/1023.0f);
+@@ -1284,10 +1291,17 @@ STAGE(srcover_rgba_8888, const SkRasterPipeline_Memory
+ auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
+
+ U32 dst = load<U32>(ptr, tail);
++#ifdef SK_CPU_BENDIAN
++ dr = cast((dst >> 24) );
++ dg = cast((dst >> 16) & 0xff);
++ db = cast((dst >> 8) & 0xff);
++ da = cast((dst ) & 0xff);
++#else
+ dr = cast((dst ) & 0xff);
+ dg = cast((dst >> 8) & 0xff);
+ db = cast((dst >> 16) & 0xff);
+ da = cast((dst >> 24) );
++#endif
+ // {dr,dg,db,da} are in [0,255]
+ // { r, g, b, a} are in [0, 1] (but may be out of gamut)
+
+@@ -1298,10 +1312,17 @@ STAGE(srcover_rgba_8888, const SkRasterPipeline_Memory
+ // { r, g, b, a} are now in [0,255] (but may be out of gamut)
+
+ // to_unorm() clamps back to gamut. Scaling by 1 since we're already 255-biased.
++#ifdef SK_CPU_BENDIAN
++ dst = to_unorm(r, 1, 255) << 24
++ | to_unorm(g, 1, 255) << 16
++ | to_unorm(b, 1, 255) << 8
++ | to_unorm(a, 1, 255);
++#else
+ dst = to_unorm(r, 1, 255)
+ | to_unorm(g, 1, 255) << 8
+ | to_unorm(b, 1, 255) << 16
+ | to_unorm(a, 1, 255) << 24;
++#endif
+ store(ptr, dst, tail);
+ }
+
+@@ -1700,10 +1721,17 @@ STAGE(gather_8888, const SkRasterPipeline_GatherCtx* c
+ STAGE(store_8888, const SkRasterPipeline_MemoryCtx* ctx) {
+ auto ptr = ptr_at_xy<uint32_t>(ctx, dx,dy);
+
++#ifdef SK_CPU_BENDIAN
++ U32 px = to_unorm(r, 255) << 24
++ | to_unorm(g, 255) << 16
++ | to_unorm(b, 255) << 8
++ | to_unorm(a, 255);
++#else
+ U32 px = to_unorm(r, 255)
+ | to_unorm(g, 255) << 8
+ | to_unorm(b, 255) << 16
+ | to_unorm(a, 255) << 24;
++#endif
+ store(ptr, px, tail);
+ }
+
+@@ -2858,10 +2886,17 @@ SI void from_8888(U32 rgba, U16* r, U16* g, U16* b, U1
+ return cast<U16>(v);
+ };
+ #endif
++#ifdef SK_CPU_BENDIAN
++ *r = cast_U16(rgba >> 16) >> 8;
++ *g = cast_U16(rgba >> 16) & 255;
++ *b = cast_U16(rgba & 65535) >> 8;
++ *a = cast_U16(rgba & 65535) & 255;
++#else
+ *r = cast_U16(rgba & 65535) & 255;
+ *g = cast_U16(rgba & 65535) >> 8;
+ *b = cast_U16(rgba >> 16) & 255;
+ *a = cast_U16(rgba >> 16) >> 8;
++#endif
+ }
+
+ SI void load_8888_(const uint32_t* ptr, size_t tail, U16* r, U16* g, U16* b, U16* a) {
+@@ -2904,8 +2939,13 @@ SI void store_8888_(uint32_t* ptr, size_t tail, U16 r,
+ case 1: vst4_lane_u8((uint8_t*)(ptr+0), rgba, 0);
+ }
+ #else
++#ifdef SK_CPU_BENDIAN
++ store(ptr, tail, cast<U32>((r<<8) | g) << 16
++ | cast<U32>((b<<8) | a) << 0);
++#else
+ store(ptr, tail, cast<U32>(r | (g<<8)) << 0
+ | cast<U32>(b | (a<<8)) << 16);
++#endif
+ #endif
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.h
@@ -0,0 +1,51 @@
+--- src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h
+@@ -120,6 +120,7 @@ class alignas(8) Value { (protected)
+ -- highest 3 bits reserved for type storage
+
+ */
++#if defined(SK_CPU_LENDIAN)
+ enum class Tag : uint8_t {
+ // We picked kShortString == 0 so that tag 0x00 and stored max_size-size (7-7=0)
+ // conveniently overlap the '\0' terminator, allowing us to store a 7 character
+@@ -134,6 +135,22 @@ class alignas(8) Value { (protected)
+ kObject = 0b11100000, // ptr to external storage
+ };
+ static constexpr uint8_t kTagMask = 0b11100000;
++#else
++ enum class Tag : uint8_t {
++ // We picked kShortString == 0 so that tag 0x00 and stored max_size-size (7-7=0)
++ // conveniently overlap the '\0' terminator, allowing us to store a 7 character
++ // C string inline.
++ kShortString = 0b00000000, // inline payload
++ kNull = 0b00000001, // no payload
++ kBool = 0b00000010, // inline payload
++ kInt = 0b00000011, // inline payload
++ kFloat = 0b00000100, // inline payload
++ kString = 0b00000101, // ptr to external storage
++ kArray = 0b00000110, // ptr to external storage
++ kObject = 0b00000111, // ptr to external storage
++ };
++ static constexpr uint8_t kTagMask = 0b00000111;
++#endif
+
+ void init_tagged(Tag);
+ void init_tagged_pointer(Tag, void*);
+@@ -192,14 +209,14 @@ class alignas(8) Value { (protected)
+
+ uint8_t fData8[kValueSize];
+
+-#if defined(SK_CPU_LENDIAN)
+ static constexpr size_t kTagOffset = kValueSize - 1;
+
++#if defined(SK_CPU_LENDIAN)
+ static constexpr uintptr_t kTagPointerMask =
+ ~(static_cast<uintptr_t>(kTagMask) << ((sizeof(uintptr_t) - 1) * 8));
+ #else
+- // The current value layout assumes LE and will take some tweaking for BE.
+- static_assert(false, "Big-endian builds are not supported at this time.");
++ static constexpr uintptr_t kTagPointerMask =
++ ~static_cast<uintptr_t>(kTagMask);
+ #endif
+ };
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.cpp
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.cpp
@@ -0,0 +1,22 @@
+--- src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp
+@@ -34,6 +34,10 @@ void Value::init_tagged(Tag t) {
+
+ // Pointer values store a type (in the upper kTagBits bits) and a pointer.
+ void Value::init_tagged_pointer(Tag t, void* p) {
++#if !defined(SK_CPU_LENDIAN)
++ // Check that kRecAlign is large enough to leave room for the tag
++ static_assert(sizeof(Value) > sizeof(uintptr_t) || !(kRecAlign & Value::kTagMask), "kRecAlign is not a multiple of kTagMask+1");
++#endif
+ *this->cast<uintptr_t>() = reinterpret_cast<uintptr_t>(p);
+
+ if (sizeof(Value) == sizeof(uintptr_t)) {
+@@ -169,7 +173,7 @@ class FastString final : public Value { (private)
+ #if defined(SK_CPU_LENDIAN)
+ *s64 &= 0x00ffffffffffffffULL >> ((kMaxInlineStringSize - size) * 8);
+ #else
+- static_assert(false, "Big-endian builds are not supported at this time.");
++ *s64 &= 0xffffffffffffff00ULL << ((kMaxInlineStringSize - size) * 8);
+ #endif
+ }
+ };
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_skcms.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_skcms.cc
@@ -0,0 +1,47 @@
+--- src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc
+@@ -66,10 +66,15 @@ static float eval_curve(const skcms_Curve* curve, floa
+ uint16_t be_l, be_h;
+ memcpy(&be_l, curve->table_16 + 2*lo, 2);
+ memcpy(&be_h, curve->table_16 + 2*hi, 2);
++#if __BIG_ENDIAN__
++ l = be_l * (1/65535.0f);
++ h = be_h * (1/65535.0f);
++#else
+ uint16_t le_l = ((be_l << 8) | (be_l >> 8)) & 0xffff;
+ uint16_t le_h = ((be_h << 8) | (be_h >> 8)) & 0xffff;
+ l = le_l * (1/65535.0f);
+ h = le_h * (1/65535.0f);
++#endif
+ }
+ return l + (h-l)*t;
+ }
+@@ -124,20 +129,28 @@ enum {
+ static uint16_t read_big_u16(const uint8_t* ptr) {
+ uint16_t be;
+ memcpy(&be, ptr, sizeof(be));
++#if __BIG_ENDIAN__
++ return be;
++#else
+ #if defined(_MSC_VER)
+ return _byteswap_ushort(be);
+ #else
+ return __builtin_bswap16(be);
+ #endif
++#endif
+ }
+
+ static uint32_t read_big_u32(const uint8_t* ptr) {
+ uint32_t be;
+ memcpy(&be, ptr, sizeof(be));
++#if __BIG_ENDIAN__
++ return be;
++#else
+ #if defined(_MSC_VER)
+ return _byteswap_ulong(be);
+ #else
+ return __builtin_bswap32(be);
++#endif
+ #endif
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_src_Transform__inl.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_src_Transform__inl.h
@@ -0,0 +1,400 @@
+--- src/3rdparty/chromium/third_party/skia/third_party/skcms/src/Transform_inl.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/skia/third_party/skcms/src/Transform_inl.h
+@@ -392,9 +392,11 @@ SI U32 gather_32(const uint8_t* p, I32 ix) {
+ }
+
+ SI U32 gather_24(const uint8_t* p, I32 ix) {
++#if !__BIG_ENDIAN__
+ // First, back up a byte. Any place we're gathering from has a safe junk byte to read
+ // in front of it, either a previous table value, or some tag metadata.
+ p -= 1;
++#endif
+
+ // Load the i'th 24-bit value from p, and 1 extra byte.
+ auto load_24_32 = [p](int i) {
+@@ -435,8 +437,10 @@ SI U32 gather_24(const uint8_t* p, I32 ix) {
+
+ #if !defined(__arm__)
+ SI void gather_48(const uint8_t* p, I32 ix, U64* v) {
++#if !__BIG_ENDIAN__
+ // As in gather_24(), with everything doubled.
+ p -= 2;
++#endif
+
+ // Load the i'th 48-bit value from p, and 2 extra bytes.
+ auto load_48_64 = [p](int i) {
+@@ -499,7 +503,9 @@ SI F F_from_U8(U8 v) {
+ SI F F_from_U16_BE(U16 v) {
+ // All 16-bit ICC values are big-endian, so we byte swap before converting to float.
+ // MSVC catches the "loss" of data here in the portable path, so we also make sure to mask.
++#if !__BIG_ENDIAN__
+ v = U16( 0 | ((v & 0x00ff) << 8) | ((v & 0xff00) >> 8) );
++#endif
+ return cast<F>(v) * (1/65535.0f);
+ }
+
+@@ -534,9 +540,15 @@ SI F table(const skcms_Curve* curve, F v) {
+ SI void sample_clut_8(const skcms_A2B* a2b, I32 ix, F* r, F* g, F* b) {
+ U32 rgb = gather_24(a2b->grid_8, ix);
+
++#if __BIG_ENDIAN__
++ *r = cast<F>((rgb >> 16) & 0xff) * (1/255.0f);
++ *g = cast<F>((rgb >> 8) & 0xff) * (1/255.0f);
++ *b = cast<F>((rgb >> 0) & 0xff) * (1/255.0f);
++#else
+ *r = cast<F>((rgb >> 0) & 0xff) * (1/255.0f);
+ *g = cast<F>((rgb >> 8) & 0xff) * (1/255.0f);
+ *b = cast<F>((rgb >> 16) & 0xff) * (1/255.0f);
++#endif
+ }
+
+ SI void sample_clut_16(const skcms_A2B* a2b, I32 ix, F* r, F* g, F* b) {
+@@ -549,12 +561,18 @@ SI void sample_clut_16(const skcms_A2B* a2b, I32 ix, F
+ // This strategy is much faster for 64-bit builds, and fine for 32-bit x86 too.
+ U64 rgb;
+ gather_48(a2b->grid_16, ix, &rgb);
++#if __BIG_ENDIAN__
++ *r = cast<F>((rgb >> 32) & 0xffff) * (1/65535.0f);
++ *g = cast<F>((rgb >> 16) & 0xffff) * (1/65535.0f);
++ *b = cast<F>((rgb >> 0) & 0xffff) * (1/65535.0f);
++#else
+ rgb = swap_endian_16x4(rgb);
+
+ *r = cast<F>((rgb >> 0) & 0xffff) * (1/65535.0f);
+ *g = cast<F>((rgb >> 16) & 0xffff) * (1/65535.0f);
+ *b = cast<F>((rgb >> 32) & 0xffff) * (1/65535.0f);
+ #endif
++#endif
+ }
+
+ // GCC 7.2.0 hits an internal compiler error with -finline-functions (or -O3)
+@@ -695,10 +713,17 @@ static void exec_ops(const Op* ops, const void** args,
+ case Op_load_8888:{
+ U32 rgba = load<U32>(src + 4*i);
+
++#if __BIG_ENDIAN__
++ r = cast<F>((rgba >> 24) & 0xff) * (1/255.0f);
++ g = cast<F>((rgba >> 16) & 0xff) * (1/255.0f);
++ b = cast<F>((rgba >> 8) & 0xff) * (1/255.0f);
++ a = cast<F>((rgba >> 0) & 0xff) * (1/255.0f);
++#else
+ r = cast<F>((rgba >> 0) & 0xff) * (1/255.0f);
+ g = cast<F>((rgba >> 8) & 0xff) * (1/255.0f);
+ b = cast<F>((rgba >> 16) & 0xff) * (1/255.0f);
+ a = cast<F>((rgba >> 24) & 0xff) * (1/255.0f);
++#endif
+ } break;
+
+ case Op_load_8888_palette8:{
+@@ -727,13 +752,29 @@ static void exec_ops(const Op* ops, const void** args,
+ const uint16_t* rgb = (const uint16_t*)ptr; // cast to const uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x3_t v = vld3_u16(rgb);
++#if __BIG_ENDIAN__
++ r = cast<F>(swap_endian_16((U16)v.val[0])) * (1/65535.0f);
++ g = cast<F>(swap_endian_16((U16)v.val[1])) * (1/65535.0f);
++ b = cast<F>(swap_endian_16((U16)v.val[2])) * (1/65535.0f);
++#else
+ r = cast<F>((U16)v.val[0]) * (1/65535.0f);
+ g = cast<F>((U16)v.val[1]) * (1/65535.0f);
+ b = cast<F>((U16)v.val[2]) * (1/65535.0f);
++#endif
+ #else
++#if __BIG_ENDIAN__
++ U32 R = load_3<U32>(rgb+0),
++ G = load_3<U32>(rgb+1),
++ B = load_3<U32>(rgb+2);
++ // R,G,B are little-endian 16-bit, so byte swap them before converting to float.
++ r = cast<F>((R & 0x00ff)<<8 | (R & 0xff00)>>8) * (1/65535.0f);
++ g = cast<F>((G & 0x00ff)<<8 | (G & 0xff00)>>8) * (1/65535.0f);
++ b = cast<F>((B & 0x00ff)<<8 | (B & 0xff00)>>8) * (1/65535.0f);
++#else
+ r = cast<F>(load_3<U32>(rgb+0)) * (1/65535.0f);
+ g = cast<F>(load_3<U32>(rgb+1)) * (1/65535.0f);
+ b = cast<F>(load_3<U32>(rgb+2)) * (1/65535.0f);
++#endif
+ #endif
+ } break;
+
+@@ -743,17 +784,33 @@ static void exec_ops(const Op* ops, const void** args,
+ const uint16_t* rgba = (const uint16_t*)ptr; // cast to const uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x4_t v = vld4_u16(rgba);
++#if __BIG_ENDIAN__
++ r = cast<F>(swap_endian_16((U16)v.val[0])) * (1/65535.0f);
++ g = cast<F>(swap_endian_16((U16)v.val[1])) * (1/65535.0f);
++ b = cast<F>(swap_endian_16((U16)v.val[2])) * (1/65535.0f);
++ a = cast<F>(swap_endian_16((U16)v.val[3])) * (1/65535.0f);
++#else
+ r = cast<F>((U16)v.val[0]) * (1/65535.0f);
+ g = cast<F>((U16)v.val[1]) * (1/65535.0f);
+ b = cast<F>((U16)v.val[2]) * (1/65535.0f);
+ a = cast<F>((U16)v.val[3]) * (1/65535.0f);
++#endif
+ #else
++#if __BIG_ENDIAN__
++ U64 px = swap_endian_16x4(load<U64>(rgba));
++
++ r = cast<F>((px >> 48) & 0xffff) * (1/65535.0f);
++ g = cast<F>((px >> 32) & 0xffff) * (1/65535.0f);
++ b = cast<F>((px >> 16) & 0xffff) * (1/65535.0f);
++ a = cast<F>((px >> 0) & 0xffff) * (1/65535.0f);
++#else
+ U64 px = load<U64>(rgba);
+
+ r = cast<F>((px >> 0) & 0xffff) * (1/65535.0f);
+ g = cast<F>((px >> 16) & 0xffff) * (1/65535.0f);
+ b = cast<F>((px >> 32) & 0xffff) * (1/65535.0f);
+ a = cast<F>((px >> 48) & 0xffff) * (1/65535.0f);
++#endif
+ #endif
+ } break;
+
+@@ -763,10 +820,21 @@ static void exec_ops(const Op* ops, const void** args,
+ const uint16_t* rgb = (const uint16_t*)ptr; // cast to const uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x3_t v = vld3_u16(rgb);
++#if __BIG_ENDIAN__
++ r = cast<F>((U16)v.val[0]) * (1/65535.0f);
++ g = cast<F>((U16)v.val[1]) * (1/65535.0f);
++ b = cast<F>((U16)v.val[2]) * (1/65535.0f);
++#else
+ r = cast<F>(swap_endian_16((U16)v.val[0])) * (1/65535.0f);
+ g = cast<F>(swap_endian_16((U16)v.val[1])) * (1/65535.0f);
+ b = cast<F>(swap_endian_16((U16)v.val[2])) * (1/65535.0f);
++#endif
+ #else
++#if __BIG_ENDIAN__
++ r = cast<F>(load_3<U32>(rgb+0)) * (1/65535.0f);
++ g = cast<F>(load_3<U32>(rgb+1)) * (1/65535.0f);
++ b = cast<F>(load_3<U32>(rgb+2)) * (1/65535.0f);
++#else
+ U32 R = load_3<U32>(rgb+0),
+ G = load_3<U32>(rgb+1),
+ B = load_3<U32>(rgb+2);
+@@ -774,6 +842,7 @@ static void exec_ops(const Op* ops, const void** args,
+ r = cast<F>((R & 0x00ff)<<8 | (R & 0xff00)>>8) * (1/65535.0f);
+ g = cast<F>((G & 0x00ff)<<8 | (G & 0xff00)>>8) * (1/65535.0f);
+ b = cast<F>((B & 0x00ff)<<8 | (B & 0xff00)>>8) * (1/65535.0f);
++#endif
+ #endif
+ } break;
+
+@@ -783,17 +852,33 @@ static void exec_ops(const Op* ops, const void** args,
+ const uint16_t* rgba = (const uint16_t*)ptr; // cast to const uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x4_t v = vld4_u16(rgba);
++#if __BIG_ENDIAN__
++ r = cast<F>((U16)v.val[0]) * (1/65535.0f);
++ g = cast<F>((U16)v.val[1]) * (1/65535.0f);
++ b = cast<F>((U16)v.val[2]) * (1/65535.0f);
++ a = cast<F>((U16)v.val[3]) * (1/65535.0f);
++#else
+ r = cast<F>(swap_endian_16((U16)v.val[0])) * (1/65535.0f);
+ g = cast<F>(swap_endian_16((U16)v.val[1])) * (1/65535.0f);
+ b = cast<F>(swap_endian_16((U16)v.val[2])) * (1/65535.0f);
+ a = cast<F>(swap_endian_16((U16)v.val[3])) * (1/65535.0f);
++#endif
+ #else
++#if __BIG_ENDIAN__
++ U64 px = load<U64>(rgba);
++
++ r = cast<F>((px >> 48) & 0xffff) * (1/65535.0f);
++ g = cast<F>((px >> 32) & 0xffff) * (1/65535.0f);
++ b = cast<F>((px >> 16) & 0xffff) * (1/65535.0f);
++ a = cast<F>((px >> 0) & 0xffff) * (1/65535.0f);
++#else
+ U64 px = swap_endian_16x4(load<U64>(rgba));
+
+ r = cast<F>((px >> 0) & 0xffff) * (1/65535.0f);
+ g = cast<F>((px >> 16) & 0xffff) * (1/65535.0f);
+ b = cast<F>((px >> 32) & 0xffff) * (1/65535.0f);
+ a = cast<F>((px >> 48) & 0xffff) * (1/65535.0f);
++#endif
+ #endif
+ } break;
+
+@@ -828,10 +913,17 @@ static void exec_ops(const Op* ops, const void** args,
+ A = (U16)v.val[3];
+ #else
+ U64 px = load<U64>(rgba);
++#if __BIG_ENDIAN__
++ U16 R = cast<U16>((px >> 48) & 0xffff),
++ G = cast<U16>((px >> 32) & 0xffff),
++ B = cast<U16>((px >> 16) & 0xffff),
++ A = cast<U16>((px >> 0) & 0xffff);
++#else
+ U16 R = cast<U16>((px >> 0) & 0xffff),
+ G = cast<U16>((px >> 16) & 0xffff),
+ B = cast<U16>((px >> 32) & 0xffff),
+ A = cast<U16>((px >> 48) & 0xffff);
++#endif
+ #endif
+ r = F_from_Half(R);
+ g = F_from_Half(G);
+@@ -1024,10 +1116,17 @@ static void exec_ops(const Op* ops, const void** args,
+ } return;
+
+ case Op_store_8888: {
++#if __BIG_ENDIAN__
++ store(dst + 4*i, cast<U32>(to_fixed(r * 255) << 24)
++ | cast<U32>(to_fixed(g * 255) << 16)
++ | cast<U32>(to_fixed(b * 255) << 8)
++ | cast<U32>(to_fixed(a * 255) << 0));
++#else
+ store(dst + 4*i, cast<U32>(to_fixed(r * 255) << 0)
+ | cast<U32>(to_fixed(g * 255) << 8)
+ | cast<U32>(to_fixed(b * 255) << 16)
+ | cast<U32>(to_fixed(a * 255) << 24));
++#endif
+ } return;
+
+ case Op_store_1010102: {
+@@ -1043,15 +1142,30 @@ static void exec_ops(const Op* ops, const void** args,
+ uint16_t* rgb = (uint16_t*)ptr; // for this cast to uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x3_t v = {{
++#if __BIG_ENDIAN__
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(r * 65535))),
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(g * 65535))),
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(b * 65535))),
++#else
+ (uint16x4_t)cast<U16>(to_fixed(r * 65535)),
+ (uint16x4_t)cast<U16>(to_fixed(g * 65535)),
+ (uint16x4_t)cast<U16>(to_fixed(b * 65535)),
++#endif
+ }};
+ vst3_u16(rgb, v);
+ #else
++#if __BIG_ENDIAN__
++ I32 R = to_fixed(r * 65535),
++ G = to_fixed(g * 65535),
++ B = to_fixed(b * 65535);
++ store_3(rgb+0, cast<U16>((R & 0x00ff) << 8 | (R & 0xff00) >> 8) );
++ store_3(rgb+1, cast<U16>((G & 0x00ff) << 8 | (G & 0xff00) >> 8) );
++ store_3(rgb+2, cast<U16>((B & 0x00ff) << 8 | (B & 0xff00) >> 8) );
++#else
+ store_3(rgb+0, cast<U16>(to_fixed(r * 65535)));
+ store_3(rgb+1, cast<U16>(to_fixed(g * 65535)));
+ store_3(rgb+2, cast<U16>(to_fixed(b * 65535)));
++#endif
+ #endif
+
+ } return;
+@@ -1062,18 +1176,33 @@ static void exec_ops(const Op* ops, const void** args,
+ uint16_t* rgba = (uint16_t*)ptr; // for this cast to uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x4_t v = {{
++#if __BIG_ENDIAN__
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(r * 65535))),
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(g * 65535))),
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(b * 65535))),
++ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(a * 65535))),
++#else
+ (uint16x4_t)cast<U16>(to_fixed(r * 65535)),
+ (uint16x4_t)cast<U16>(to_fixed(g * 65535)),
+ (uint16x4_t)cast<U16>(to_fixed(b * 65535)),
+ (uint16x4_t)cast<U16>(to_fixed(a * 65535)),
++#endif
+ }};
+ vst4_u16(rgba, v);
+ #else
++#if __BIG_ENDIAN__
++ U64 px = cast<U64>(to_fixed(r * 65535)) << 48
++ | cast<U64>(to_fixed(g * 65535)) << 32
++ | cast<U64>(to_fixed(b * 65535)) << 16
++ | cast<U64>(to_fixed(a * 65535)) << 0;
++ store(rgba, swap_endian_16x4(px));
++#else
+ U64 px = cast<U64>(to_fixed(r * 65535)) << 0
+ | cast<U64>(to_fixed(g * 65535)) << 16
+ | cast<U64>(to_fixed(b * 65535)) << 32
+ | cast<U64>(to_fixed(a * 65535)) << 48;
+ store(rgba, px);
++#endif
+ #endif
+ } return;
+
+@@ -1083,18 +1212,30 @@ static void exec_ops(const Op* ops, const void** args,
+ uint16_t* rgb = (uint16_t*)ptr; // for this cast to uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x3_t v = {{
++#if __BIG_ENDIAN__
++ (uint16x4_t)cast<U16>(to_fixed(r * 65535)),
++ (uint16x4_t)cast<U16>(to_fixed(g * 65535)),
++ (uint16x4_t)cast<U16>(to_fixed(b * 65535)),
++#else
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(r * 65535))),
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(g * 65535))),
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(b * 65535))),
++#endif
+ }};
+ vst3_u16(rgb, v);
+ #else
++#if __BIG_ENDIAN__
++ store_3(rgb+0, cast<U16>(to_fixed(r * 65535)));
++ store_3(rgb+1, cast<U16>(to_fixed(g * 65535)));
++ store_3(rgb+2, cast<U16>(to_fixed(b * 65535)));
++#else
+ I32 R = to_fixed(r * 65535),
+ G = to_fixed(g * 65535),
+ B = to_fixed(b * 65535);
+ store_3(rgb+0, cast<U16>((R & 0x00ff) << 8 | (R & 0xff00) >> 8) );
+ store_3(rgb+1, cast<U16>((G & 0x00ff) << 8 | (G & 0xff00) >> 8) );
+ store_3(rgb+2, cast<U16>((B & 0x00ff) << 8 | (B & 0xff00) >> 8) );
++#endif
+ #endif
+
+ } return;
+@@ -1105,18 +1246,33 @@ static void exec_ops(const Op* ops, const void** args,
+ uint16_t* rgba = (uint16_t*)ptr; // for this cast to uint16_t* to be safe.
+ #if defined(USING_NEON)
+ uint16x4x4_t v = {{
++#if __BIG_ENDIAN__
++ (uint16x4_t)cast<U16>(to_fixed(r * 65535)),
++ (uint16x4_t)cast<U16>(to_fixed(g * 65535)),
++ (uint16x4_t)cast<U16>(to_fixed(b * 65535)),
++ (uint16x4_t)cast<U16>(to_fixed(a * 65535)),
++#else
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(r * 65535))),
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(g * 65535))),
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(b * 65535))),
+ (uint16x4_t)swap_endian_16(cast<U16>(to_fixed(a * 65535))),
++#endif
+ }};
+ vst4_u16(rgba, v);
+ #else
++#if __BIG_ENDIAN__
++ U64 px = cast<U64>(to_fixed(r * 65535)) << 48
++ | cast<U64>(to_fixed(g * 65535)) << 32
++ | cast<U64>(to_fixed(b * 65535)) << 16
++ | cast<U64>(to_fixed(a * 65535)) << 0;
++ store(rgba, px);
++#else
+ U64 px = cast<U64>(to_fixed(r * 65535)) << 0
+ | cast<U64>(to_fixed(g * 65535)) << 16
+ | cast<U64>(to_fixed(b * 65535)) << 32
+ | cast<U64>(to_fixed(a * 65535)) << 48;
+ store(rgba, swap_endian_16x4(px));
++#endif
+ #endif
+ } return;
+
+@@ -1160,10 +1316,17 @@ static void exec_ops(const Op* ops, const void** args,
+ }};
+ vst4_u16(rgba, v);
+ #else
++#if __BIG_ENDIAN__
++ store(rgba, cast<U64>(R) << 48
++ | cast<U64>(G) << 32
++ | cast<U64>(B) << 16
++ | cast<U64>(A) << 0);
++#else
+ store(rgba, cast<U64>(R) << 0
+ | cast<U64>(G) << 16
+ | cast<U64>(B) << 32
+ | cast<U64>(A) << 48);
++#endif
+ #endif
+
+ } return;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_smhasher_src_City.cpp
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_smhasher_src_City.cpp
@@ -0,0 +1,17 @@
+--- src/3rdparty/chromium/third_party/smhasher/src/City.cpp.orig 2019-10-27 22:10:58.672918000 +0100
++++ src/3rdparty/chromium/third_party/smhasher/src/City.cpp 2019-10-27 22:12:39.653255000 +0100
+@@ -65,11 +65,11 @@
+ #define bswap_64(x) OSSwapInt64(x)
+
+ #else
+-#include <byteswap.h>
++#include <sys/endian.h>
+ #endif
+
+-#define uint32_in_expected_order(x) (bswap_32(x))
+-#define uint64_in_expected_order(x) (bswap_64(x))
++#define uint32_in_expected_order(x) (bswap32(x))
++#define uint64_in_expected_order(x) (bswap64(x))
+
+ #endif // __BIG_ENDIAN__
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__file.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__file.cc
@@ -0,0 +1,50 @@
+--- src/3rdparty/chromium/third_party/webrtc/common_audio/wav_file.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/webrtc/common_audio/wav_file.cc
+@@ -93,13 +93,15 @@ size_t WavReader::num_samples() const {
+ }
+
+ size_t WavReader::ReadSamples(size_t num_samples, int16_t* samples) {
+-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#error "Need to convert samples to big-endian when reading from WAV file"
+-#endif
+ // There could be metadata after the audio; ensure we don't read it.
+ num_samples = std::min(num_samples, num_samples_remaining_);
+ const size_t read =
+ fread(samples, sizeof(*samples), num_samples, file_handle_);
++#ifndef WEBRTC_ARCH_LITTLE_ENDIAN
++ for (size_t i = 0; i < read; i++) {
++ samples[i] = __builtin_bswap16(samples[i]);
++ }
++#endif
+ // If we didn't read what was requested, ensure we've reached the EOF.
+ RTC_CHECK(read == num_samples || feof(file_handle_));
+ RTC_CHECK_LE(read, num_samples_remaining_);
+@@ -178,13 +180,26 @@ size_t WavWriter::num_samples() const {
+
+ void WavWriter::WriteSamples(const int16_t* samples, size_t num_samples) {
+ #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
+-#error "Need to convert samples to little-endian when writing to WAV file"
+-#endif
++ static const size_t kChunksize = 4096 / sizeof(uint16_t);
++ for (size_t i = 0; i < num_samples; i += kChunksize) {
++ int16_t isamples[kChunksize];
++ const size_t chunk = std::min(kChunksize, num_samples - i);
++ for (size_t j = 0; j < chunk; j++) {
++ isamples[j] = __builtin_bswap16(samples[i + j]);
++ }
++ const size_t written =
++ fwrite(isamples, sizeof(*isamples), chunk, file_handle_);
++ RTC_CHECK_EQ(chunk, written);
++ num_samples_ += written;
++ RTC_CHECK(num_samples_ >= written); // detect size_t overflow
++ }
++#else
+ const size_t written =
+ fwrite(samples, sizeof(*samples), num_samples, file_handle_);
+ RTC_CHECK_EQ(num_samples, written);
+ num_samples_ += written;
+ RTC_CHECK(num_samples_ >= written); // detect size_t overflow
++#endif
+ }
+
+ void WavWriter::WriteSamples(const float* samples, size_t num_samples) {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__header.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__header.cc
@@ -0,0 +1,30 @@
+--- src/3rdparty/chromium/third_party/webrtc/common_audio/wav_header.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/webrtc/common_audio/wav_header.cc
+@@ -86,7 +86,26 @@ static inline std::string ReadFourCC(uint32_t x) {
+ return std::string(reinterpret_cast<char*>(&x), 4);
+ }
+ #else
+-#error "Write be-to-le conversion functions"
++static inline void WriteLE16(uint16_t* f, uint16_t x) {
++ *f = __builtin_bswap16(x);
++}
++static inline void WriteLE32(uint32_t* f, uint32_t x) {
++ *f = __builtin_bswap32(x);
++}
++static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
++ *f = static_cast<uint32_t>(d) | static_cast<uint32_t>(c) << 8 |
++ static_cast<uint32_t>(b) << 16 | static_cast<uint32_t>(a) << 24;
++}
++
++static inline uint16_t ReadLE16(uint16_t x) {
++ return __builtin_bswap16(x);
++}
++static inline uint32_t ReadLE32(uint32_t x) {
++ return __builtin_bswap32(x);
++}
++static inline std::string ReadFourCC(uint32_t x) {
++ return std::string(reinterpret_cast<char*>(&x), 4);
++}
+ #endif
+
+ static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_modules_desktop__capture_differ__block.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_modules_desktop__capture_differ__block.cc
@@ -0,0 +1,26 @@
+--- src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc
+@@ -30,11 +30,7 @@ bool VectorDifference(const uint8_t* image1, const uin
+ static bool (*diff_proc)(const uint8_t*, const uint8_t*) = nullptr;
+
+ if (!diff_proc) {
+-#if defined(WEBRTC_ARCH_ARM_FAMILY) || defined(WEBRTC_ARCH_MIPS_FAMILY)
+- // For ARM and MIPS processors, always use C version.
+- // TODO(hclam): Implement a NEON version.
+- diff_proc = &VectorDifference_C;
+-#else
++#if defined(WEBRTC_ARCH_X86_FAMILY)
+ bool have_sse2 = WebRtc_GetCPUInfo(kSSE2) != 0;
+ // For x86 processors, check if SSE2 is supported.
+ if (have_sse2 && kBlockSize == 32) {
+@@ -44,6 +40,10 @@ bool VectorDifference(const uint8_t* image1, const uin
+ } else {
+ diff_proc = &VectorDifference_C;
+ }
++#else
++ // For other processors, always use C version.
++ // TODO(hclam): Implement a NEON version.
++ diff_proc = &VectorDifference_C;
+ #endif
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_rtc__base_system_arch.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_rtc__base_system_arch.h
@@ -0,0 +1,21 @@
+--- src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h
+@@ -47,6 +47,18 @@
+ #elif defined(__pnacl__)
+ #define WEBRTC_ARCH_32_BITS
+ #define WEBRTC_ARCH_LITTLE_ENDIAN
++#elif defined(__PPC__)
++#define WEBRTC_ARCH_PPC_FAMILY
++#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
++#define WEBRTC_ARCH_LITTLE_ENDIAN
++#else
++#define WEBRTC_ARCH_BIG_ENDIAN
++#endif
++#if defined(__LP64__)
++#define WEBRTC_ARCH_64_BITS
++#else
++#define WEBRTC_ARCH_32_BITS
++#endif
+ #else
+ #error Please add support for your architecture in typedefs.h
+ #endif
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_aura_mus_os__exchange__data__provider__mus.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_aura_mus_os__exchange__data__provider__mus.cc
@@ -0,0 +1,24 @@
+--- src/3rdparty/chromium/ui/aura/mus/os_exchange_data_provider_mus.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/aura/mus/os_exchange_data_provider_mus.cc
+@@ -14,6 +14,7 @@
+ #include "base/strings/string_split.h"
+ #include "base/strings/string_util.h"
+ #include "base/strings/utf_string_conversions.h"
++#include "base/sys_byteorder.h"
+ #include "net/base/filename_util.h"
+ #include "ui/base/clipboard/clipboard_constants.h"
+ #include "ui/base/clipboard/clipboard_format_type.h"
+@@ -279,8 +280,13 @@ void OSExchangeDataProviderMus::SetHtml(const base::st
+ std::vector<unsigned char> bytes;
+ // Manually jam a UTF16 BOM into bytes because otherwise, other programs will
+ // assume UTF-8.
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ bytes.push_back(0xFF);
+ bytes.push_back(0xFE);
++#else
++ bytes.push_back(0xFE);
++ bytes.push_back(0xFF);
++#endif
+ AddString16ToVector(html, &bytes);
+ mime_data_[ui::kMimeTypeHTML] = bytes;
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_base_resource_data__pack.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_base_resource_data__pack.cc
@@ -0,0 +1,166 @@
+--- src/3rdparty/chromium/ui/base/resource/data_pack.cc.orig 2019-10-27 17:39:58 UTC
++++ src/3rdparty/chromium/ui/base/resource/data_pack.cc
+@@ -154,16 +154,42 @@ class ScopedFileWriter {
+ DISALLOW_COPY_AND_ASSIGN(ScopedFileWriter);
+ };
+
++static inline uint16_t byteswap(uint16_t v) { return __builtin_bswap16(v); }
++static inline uint32_t byteswap(uint32_t v) { return __builtin_bswap32(v); }
++
++template<class T> class byteswapped_t {
++private:
++ T value;
++public:
++ inline byteswapped_t(T v) : value(byteswap(v)) { }
++ inline T operator=(T v) { value = byteswap(v); return v; }
++ inline T operator+=(T v) { v += byteswap(value); value = byteswap(v); return v; }
++ inline operator T() const { return byteswap(value); }
++};
++
++#if !defined(ARCH_CPU_LITTLE_ENDIAN)
++
++typedef byteswapped_t<uint16_t> uint16le_t;
++typedef byteswapped_t<uint32_t> uint32le_t;
++
++#else
++
++typedef uint16_t uint16le_t;
++typedef uint32_t uint32le_t;
++
++#endif
++
+ } // namespace
+
+ namespace ui {
+
+ #pragma pack(push, 2)
+ struct DataPack::Entry {
+- uint16_t resource_id;
+- uint32_t file_offset;
++ uint16le_t resource_id;
++ uint32le_t file_offset;
+
+ static int CompareById(const void* void_key, const void* void_entry) {
++ // Key is host endian
+ uint16_t key = *reinterpret_cast<const uint16_t*>(void_key);
+ const Entry* entry = reinterpret_cast<const Entry*>(void_entry);
+ return key - entry->resource_id;
+@@ -171,10 +197,11 @@ struct DataPack::Entry {
+ };
+
+ struct DataPack::Alias {
+- uint16_t resource_id;
+- uint16_t entry_index;
++ uint16le_t resource_id;
++ uint16le_t entry_index;
+
+ static int CompareById(const void* void_key, const void* void_entry) {
++ // Key is host endian
+ uint16_t key = *reinterpret_cast<const uint16_t*>(void_key);
+ const Alias* entry = reinterpret_cast<const Alias*>(void_entry);
+ return key - entry->resource_id;
+@@ -284,7 +311,7 @@ bool DataPack::LoadImpl(std::unique_ptr<DataPack::Data
+ // Parse the version and check for truncated header.
+ uint32_t version = 0;
+ if (data_length > sizeof(version))
+- version = reinterpret_cast<const uint32_t*>(data)[0];
++ version = reinterpret_cast<const uint32le_t*>(data)[0];
+ size_t header_length =
+ version == kFileFormatV4 ? kHeaderLengthV4 : kHeaderLengthV5;
+ if (version == 0 || data_length < header_length) {
+@@ -295,14 +322,14 @@ bool DataPack::LoadImpl(std::unique_ptr<DataPack::Data
+
+ // Parse the header of the file.
+ if (version == kFileFormatV4) {
+- resource_count_ = reinterpret_cast<const uint32_t*>(data)[1];
++ resource_count_ = reinterpret_cast<const uint32le_t*>(data)[1];
+ alias_count_ = 0;
+ text_encoding_type_ = static_cast<TextEncodingType>(data[8]);
+ } else if (version == kFileFormatV5) {
+ // Version 5 added the alias table and changed the header format.
+ text_encoding_type_ = static_cast<TextEncodingType>(data[4]);
+- resource_count_ = reinterpret_cast<const uint16_t*>(data)[4];
+- alias_count_ = reinterpret_cast<const uint16_t*>(data)[5];
++ resource_count_ = reinterpret_cast<const uint16le_t*>(data)[4];
++ alias_count_ = reinterpret_cast<const uint16le_t*>(data)[5];
+ } else {
+ LOG(ERROR) << "Bad data pack version: got " << version << ", expected "
+ << kFileFormatV4 << " or " << kFileFormatV5;
+@@ -382,12 +382,6 @@ bool DataPack::HasResource(uint16_t resource_id) const {
+
+ bool DataPack::GetStringPiece(uint16_t resource_id,
+ base::StringPiece* data) const {
+- // It won't be hard to make this endian-agnostic, but it's not worth
+- // bothering to do right now.
+-#if !defined(ARCH_CPU_LITTLE_ENDIAN)
+-#error "datapack assumes little endian"
+-#endif
+-
+ const Entry* target = LookupEntryById(resource_id);
+ if (!target)
+ return false;
+@@ -447,9 +480,6 @@ void DataPack::CheckForDuplicateResources(
+ bool DataPack::WritePack(const base::FilePath& path,
+ const std::map<uint16_t, base::StringPiece>& resources,
+ TextEncodingType text_encoding_type) {
+-#if !defined(ARCH_CPU_LITTLE_ENDIAN)
+-#error "datapack assumes little endian"
+-#endif
+ if (text_encoding_type != UTF8 && text_encoding_type != UTF16 &&
+ text_encoding_type != BINARY) {
+ LOG(ERROR) << "Invalid text encoding type, got " << text_encoding_type
+@@ -467,7 +497,7 @@ bool DataPack::WritePack(const base::FilePath& path,
+ if (!file.valid())
+ return false;
+
+- uint32_t encoding = static_cast<uint32_t>(text_encoding_type);
++ uint32le_t encoding = static_cast<uint32le_t>(text_encoding_type);
+
+ // Build a list of final resource aliases, and an alias map at the same time.
+ std::vector<uint16_t> resource_ids;
+@@ -494,13 +524,14 @@ bool DataPack::WritePack(const base::FilePath& path,
+
+ // These values are guaranteed to fit in a uint16_t due to the earlier
+ // check of |resources_count|.
+- const uint16_t alias_count = static_cast<uint16_t>(aliases.size());
+- const uint16_t entry_count = static_cast<uint16_t>(resource_ids.size());
++ const uint16le_t alias_count = static_cast<uint16le_t>(aliases.size());
++ const uint16le_t entry_count = static_cast<uint16le_t>(resource_ids.size());
+ DCHECK_EQ(static_cast<size_t>(entry_count) + static_cast<size_t>(alias_count),
+ resources_count);
+
+- file.Write(&kFileFormatV5, sizeof(kFileFormatV5));
+- file.Write(&encoding, sizeof(uint32_t));
++ uint32le_t version = kFileFormatV5;
++ file.Write(&version, sizeof(version));
++ file.Write(&encoding, sizeof(uint32le_t));
+ file.Write(&entry_count, sizeof(entry_count));
+ file.Write(&alias_count, sizeof(alias_count));
+
+@@ -508,8 +539,8 @@ bool DataPack::WritePack(const base::FilePath& path,
+ // last item so we can compute the size of the list item.
+ const uint32_t index_length = (entry_count + 1) * sizeof(Entry);
+ const uint32_t alias_table_length = alias_count * sizeof(Alias);
+- uint32_t data_offset = kHeaderLengthV5 + index_length + alias_table_length;
+- for (const uint16_t resource_id : resource_ids) {
++ uint32le_t data_offset = kHeaderLengthV5 + index_length + alias_table_length;
++ for (const uint16le_t resource_id : resource_ids) {
+ file.Write(&resource_id, sizeof(resource_id));
+ file.Write(&data_offset, sizeof(data_offset));
+ data_offset += resources.find(resource_id)->second.length();
+@@ -517,13 +548,13 @@ bool DataPack::WritePack(const base::FilePath& path,
+
+ // We place an extra entry after the last item that allows us to read the
+ // size of the last item.
+- const uint16_t resource_id = 0;
++ const uint16le_t resource_id = 0;
+ file.Write(&resource_id, sizeof(resource_id));
+ file.Write(&data_offset, sizeof(data_offset));
+
+ // Write the aliases table, if any. Note: |aliases| is an std::map,
+ // ensuring values are written in increasing order.
+- for (const std::pair<uint16_t, uint16_t>& alias : aliases) {
++ for (const std::pair<uint16le_t, uint16le_t> alias : aliases) {
+ file.Write(&alias, sizeof(alias));
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc
@@ -1,6 +1,6 @@
---- src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc.orig 2018-11-13 18:25:11 UTC
-+++ src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc
-@@ -219,6 +219,7 @@ bool JPEGCodec::Decode(const unsigned char* input, siz
+--- src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc 2019-10-27 22:18:49.231847000 +0100
+@@ -207,16 +207,17 @@
case JCS_GRAYSCALE:
case JCS_RGB:
case JCS_YCbCr:
@@ -8,13 +8,25 @@
// Choose an output colorspace and return if it is an unsupported one.
// Same as JPEGCodec::Encode(), libjpeg-turbo supports all input formats
// used by Chromium (i.e. RGBA and BGRA) and we just map the input
-@@ -237,6 +238,9 @@ bool JPEGCodec::Decode(const unsigned char* input, siz
- NOTREACHED() << "Invalid pixel format";
+ // parameters to a colorspace.
+ if (format == FORMAT_RGBA ||
+- (format == FORMAT_SkBitmap && SK_R32_SHIFT == 0)) {
++ (format == FORMAT_SkBitmap && SK_PMCOLOR_BYTE_ORDER(R, G, B, A))) {
+ cinfo->out_color_space = JCS_EXT_RGBX;
+ cinfo->output_components = 4;
+ } else if (format == FORMAT_BGRA ||
+- (format == FORMAT_SkBitmap && SK_B32_SHIFT == 0)) {
++ (format == FORMAT_SkBitmap && SK_PMCOLOR_BYTE_ORDER(B, G, R, A))) {
+ cinfo->out_color_space = JCS_EXT_BGRX;
+ cinfo->output_components = 4;
+ } else {
+@@ -224,6 +225,9 @@
return false;
}
+ break;
+#else
+ cinfo.out_color_space = JCS_RGB;
+#endif
- break;
case JCS_CMYK:
case JCS_YCCK:
+ default:
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.h
@@ -0,0 +1,13 @@
+--- src/3rdparty/chromium/ui/gfx/codec/png_codec.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/gfx/codec/png_codec.h
+@@ -37,6 +37,10 @@ class CODEC_EXPORT PNGCodec {
+ // This is the default Windows DIB order.
+ FORMAT_BGRA,
+
++ // 4 bytes per pixel, in ARGB order in memory regardless of endianness.
++ // Only supported for decoding
++ FORMAT_ARGB,
++
+ // SkBitmap format. For Encode() kN32_SkColorType (4 bytes per pixel) and
+ // kAlpha_8_SkColorType (1 byte per pixel) formats are supported.
+ // kAlpha_8_SkColorType gets encoded into a grayscale PNG treating alpha as
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.cc
@@ -0,0 +1,33 @@
+--- src/3rdparty/chromium/ui/gfx/codec/png_codec.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/gfx/codec/png_codec.cc
+@@ -169,6 +169,10 @@ void DecodeInfoCallback(png_struct* png_ptr, png_info*
+ png_set_bgr(png_ptr);
+ png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+ break;
++ case PNGCodec::FORMAT_ARGB:
++ state->output_channels = 4;
++ png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_BEFORE);
++ break;
+ case PNGCodec::FORMAT_SkBitmap:
+ state->output_channels = 4;
+ png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
+@@ -183,6 +187,10 @@ void DecodeInfoCallback(png_struct* png_ptr, png_info*
+ state->output_channels = 4;
+ png_set_bgr(png_ptr);
+ break;
++ case PNGCodec::FORMAT_ARGB:
++ state->output_channels = 4;
++ png_set_swap_alpha(png_ptr);
++ break;
+ case PNGCodec::FORMAT_SkBitmap:
+ state->output_channels = 4;
+ break;
+@@ -475,6 +483,8 @@ bool PNGCodec::Encode(const unsigned char* input,
+ case FORMAT_BGRA:
+ colorType = kBGRA_8888_SkColorType;
+ break;
++ case FORMAT_ARGB:
++ return false;
+ case FORMAT_SkBitmap:
+ colorType = kN32_SkColorType;
+ break;
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec__unittest.cc
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc
+@@ -853,7 +853,7 @@ TEST(PNGCodec, EncodeA8SkBitmap) {
+ for (int y = 0; y < h; y++) {
+ uint8_t original_pixel = *original_bitmap.getAddr8(x, y);
+ uint32_t decoded_pixel = *decoded_bitmap.getAddr32(x, y);
+- EXPECT_TRUE(BGRAGrayEqualsA8Gray(decoded_pixel, original_pixel));
++ EXPECT_TRUE(BGRAGrayEqualsA8Gray(SkUnPreMultiply::PMColorToColor(decoded_pixel), original_pixel));
+ }
+ }
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_color__analysis.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_color__analysis.cc
@@ -0,0 +1,87 @@
+--- src/3rdparty/chromium/ui/gfx/color_analysis.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/gfx/color_analysis.cc
+@@ -16,6 +16,7 @@
+ #include <vector>
+
+ #include "base/logging.h"
++#include "base/sys_byteorder.h"
+ #include "third_party/skia/include/core/SkBitmap.h"
+ #include "third_party/skia/include/core/SkUnPreMultiply.h"
+ #include "ui/gfx/codec/png_codec.h"
+@@ -506,10 +507,17 @@ SkColor FindClosestColor(const uint8_t* image,
+ SkColor best_color = color;
+ const uint8_t* byte = image;
+ for (int i = 0; i < width * height; ++i) {
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ uint8_t b = *(byte++);
+ uint8_t g = *(byte++);
+ uint8_t r = *(byte++);
+ uint8_t a = *(byte++);
++#else
++ uint8_t a = *(byte++);
++ uint8_t r = *(byte++);
++ uint8_t g = *(byte++);
++ uint8_t b = *(byte++);
++#endif
+ // Ignore fully transparent pixels.
+ if (a == 0)
+ continue;
+@@ -527,7 +535,6 @@ SkColor FindClosestColor(const uint8_t* image,
+
+ // For a 16x16 icon on an Intel Core i5 this function takes approximately
+ // 0.5 ms to run.
+-// TODO(port): This code assumes the CPU architecture is little-endian.
+ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data,
+ int img_width,
+ int img_height,
+@@ -550,10 +557,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_d
+ int pixel_pos = sampler->GetSample(img_width, img_height) %
+ (img_width * img_height);
+
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ uint8_t b = decoded_data[pixel_pos * 4];
+ uint8_t g = decoded_data[pixel_pos * 4 + 1];
+ uint8_t r = decoded_data[pixel_pos * 4 + 2];
+ uint8_t a = decoded_data[pixel_pos * 4 + 3];
++#else
++ uint8_t a = decoded_data[pixel_pos * 4];
++ uint8_t r = decoded_data[pixel_pos * 4 + 1];
++ uint8_t g = decoded_data[pixel_pos * 4 + 2];
++ uint8_t b = decoded_data[pixel_pos * 4 + 3];
++#endif
+ // Skip fully transparent pixels as they usually contain black in their
+ // RGB channels but do not contribute to the visual image.
+ if (a == 0)
+@@ -602,10 +616,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_d
+ uint8_t* pixel = decoded_data;
+ uint8_t* decoded_data_end = decoded_data + (img_width * img_height * 4);
+ while (pixel < decoded_data_end) {
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
+ uint8_t b = *(pixel++);
+ uint8_t g = *(pixel++);
+ uint8_t r = *(pixel++);
+ uint8_t a = *(pixel++);
++#else
++ uint8_t a = *(pixel++);
++ uint8_t r = *(pixel++);
++ uint8_t g = *(pixel++);
++ uint8_t b = *(pixel++);
++#endif
+ // Skip transparent pixels, see above.
+ if (a == 0)
+ continue;
+@@ -683,8 +704,12 @@ SkColor CalculateKMeanColorOfPNG(scoped_refptr<base::R
+
+ if (png.get() && png->size() &&
+ gfx::PNGCodec::Decode(png->front(), png->size(),
+- gfx::PNGCodec::FORMAT_BGRA, &decoded_data,
+- &img_width, &img_height)) {
++#if defined(ARCH_CPU_LITTLE_ENDIAN)
++ gfx::PNGCodec::FORMAT_BGRA,
++#else
++ gfx::PNGCodec::FORMAT_ARGB,
++#endif
++ &decoded_data, &img_width, &img_height)) {
+ return CalculateKMeanColorOfBuffer(&decoded_data[0], img_width, img_height,
+ lower_bound, upper_bound, sampler, true);
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_skbitmap__operations__unittest.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_skbitmap__operations__unittest.cc
@@ -0,0 +1,11 @@
+--- src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc
+@@ -238,7 +238,7 @@ TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapHue
+
+ for (int y = 0, i = 0; y < src_h; y++) {
+ for (int x = 0; x < src_w; x++) {
+- *src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255);
++ *src.getAddr32(x, y) = SkPackARGB32(255, 0, 0, i % 255);
+ i++;
+ }
+ }
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__host.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__host.cc
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/url/url_canon_host.cc.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/url/url_canon_host.cc
+@@ -135,8 +135,7 @@ bool DoSimpleHost(const INCHAR* host,
+ if (source == '%') {
+ // Unescape first, if possible.
+ // Source will be used only if decode operation was successful.
+- if (!DecodeEscaped(host, &i, host_len,
+- reinterpret_cast<unsigned char*>(&source))) {
++ if (!DecodeEscaped(host, &i, host_len, &source)) {
+ // Invalid escaped character. There is nothing that can make this
+ // host valid. We append an escaped percent so the URL looks reasonable
+ // and mark as failed.
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__internal.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__internal.h
@@ -0,0 +1,14 @@
+--- src/3rdparty/chromium/url/url_canon_internal.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/url/url_canon_internal.h
+@@ -305,9 +305,9 @@ inline bool Is8BitChar(base::char16 c) {
+ return c <= 255;
+ }
+
+-template<typename CHAR>
++template<typename CHAR, typename DST>
+ inline bool DecodeEscaped(const CHAR* spec, int* begin, int end,
+- unsigned char* unescaped_value) {
++ DST* unescaped_value) {
+ if (*begin + 3 > end ||
+ !Is8BitChar(spec[*begin + 1]) || !Is8BitChar(spec[*begin + 2])) {
+ // Invalid escape sequence because there's not enough room, or the
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn
===================================================================
--- www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn
@@ -1,6 +1,14 @@
---- src/3rdparty/chromium/v8/BUILD.gn.orig 2019-05-23 12:39:34 UTC
-+++ src/3rdparty/chromium/v8/BUILD.gn
-@@ -3169,7 +3169,7 @@ v8_component("v8_libbase") {
+--- src/3rdparty/chromium/v8/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200
++++ src/3rdparty/chromium/v8/BUILD.gn 2019-10-27 22:44:17.280181000 +0100
+@@ -3006,7 +3006,6 @@
+ # to implement atomic memory access
+ if (v8_current_cpu == "mips" || v8_current_cpu == "mipsel" ||
+ v8_current_cpu == "mips64" || v8_current_cpu == "mips64el" ||
+- v8_current_cpu == "ppc" || v8_current_cpu == "ppc64" ||
+ v8_current_cpu == "s390" || v8_current_cpu == "s390x") {
+ libs = [ "atomic" ]
+ }
+@@ -3169,7 +3168,7 @@
}
}
@@ -9,7 +17,7 @@
sources += [
"src/base/debug/stack_trace_posix.cc",
"src/base/platform/platform-linux.cc",
-@@ -3189,6 +3189,12 @@ v8_component("v8_libbase") {
+@@ -3189,6 +3188,12 @@
"dl",
"rt",
]
@@ -22,7 +30,7 @@
} else if (is_android) {
if (current_toolchain == host_toolchain) {
libs = [
-@@ -3393,6 +3399,7 @@ if (v8_use_snapshot && current_toolchain == v8_snapsho
+@@ -3393,6 +3398,7 @@
"src/snapshot/embedded-file-writer.h",
"src/snapshot/mksnapshot.cc",
]
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_constants-ppc.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_constants-ppc.h
@@ -0,0 +1,30 @@
+--- src/3rdparty/chromium/v8/src/ppc/constants-ppc.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/v8/src/ppc/constants-ppc.h
+@@ -21,7 +21,8 @@
+ #endif
+
+ #if V8_HOST_ARCH_PPC && \
+- (V8_OS_AIX || (V8_TARGET_ARCH_PPC64 && V8_TARGET_BIG_ENDIAN))
++ (V8_OS_AIX || (V8_TARGET_ARCH_PPC64 && \
++ (V8_TARGET_BIG_ENDIAN && (!defined(_CALL_ELF) || _CALL_ELF == 1))))
+ #define ABI_USES_FUNCTION_DESCRIPTORS 1
+ #else
+ #define ABI_USES_FUNCTION_DESCRIPTORS 0
+@@ -33,13 +34,15 @@
+ #define ABI_PASSES_HANDLES_IN_REGS 0
+ #endif
+
+-#if !V8_HOST_ARCH_PPC || !V8_TARGET_ARCH_PPC64 || V8_TARGET_LITTLE_ENDIAN
++#if !V8_HOST_ARCH_PPC || !V8_TARGET_ARCH_PPC64 || \
++ (V8_TARGET_LITTLE_ENDIAN || (defined(_CALL_ELF) && _CALL_ELF == 2))
+ #define ABI_RETURNS_OBJECT_PAIRS_IN_REGS 1
+ #else
+ #define ABI_RETURNS_OBJECT_PAIRS_IN_REGS 0
+ #endif
+
+-#if !V8_HOST_ARCH_PPC || (V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN)
++#if !V8_HOST_ARCH_PPC || (V8_TARGET_ARCH_PPC64 && \
++ (V8_TARGET_LITTLE_ENDIAN || (defined(_CALL_ELF) && _CALL_ELF == 2)))
+ #define ABI_CALL_VIA_IP 1
+ #else
+ #define ABI_CALL_VIA_IP 0
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_register-ppc.h
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_register-ppc.h
@@ -0,0 +1,12 @@
+--- src/3rdparty/chromium/v8/src/ppc/register-ppc.h.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/v8/src/ppc/register-ppc.h
+@@ -145,7 +145,8 @@ const int kNumSafepointRegisters = 32;
+ // The following constants describe the stack frame linkage area as
+ // defined by the ABI. Note that kNumRequiredStackFrameSlots must
+ // satisfy alignment requirements (rounding up if required).
+-#if V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN // ppc64le linux
++#if V8_TARGET_ARCH_PPC64 && (V8_TARGET_LITTLE_ENDIAN || \
++ defined(_CALL_ELF) && _CALL_ELF == 2)
+ // [0] back chain
+ // [1] condition register save area
+ // [2] link register save area
Index: www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_test_BUILD.gn
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_test_BUILD.gn
@@ -0,0 +1,36 @@
+--- src/3rdparty/chromium/v8/test/BUILD.gn.orig 2019-05-23 12:39:34 UTC
++++ src/3rdparty/chromium/v8/test/BUILD.gn
+@@ -31,7 +31,7 @@ group("gn_all") {
+ deps += [
+ "cctest:cctest",
+ "cctest:generate-bytecode-expectations",
+- "unittests:unittests",
++ #"unittests:unittests",
+ ]
+ }
+ }
+@@ -80,9 +80,9 @@ group("v8_bot_default") {
+ "mjsunit:v8_mjsunit",
+ "mkgrokdump:mkgrokdump",
+ "preparser:v8_preparser",
+- "unittests:unittests",
++ #"unittests:unittests",
+ "wasm-js:v8_wasm_js",
+- "wasm-spec-tests:v8_wasm_spec_tests",
++ #"wasm-spec-tests:v8_wasm_spec_tests",
+ "webkit:v8_webkit",
+ ]
+ }
+@@ -100,9 +100,9 @@ group("v8_default") {
+ "mjsunit:v8_mjsunit",
+ "mkgrokdump:mkgrokdump",
+ "preparser:v8_preparser",
+- "unittests:unittests",
+- "wasm-js:v8_wasm_js",
+- "wasm-spec-tests:v8_wasm_spec_tests",
++ #"unittests:unittests",
++ #"wasm-js:v8_wasm_js",
++ #"wasm-spec-tests:v8_wasm_spec_tests",
+ ]
+ }
+
Index: www/qt5-webengine/files/patch-src_3rdparty_gn_tools_gn_args.cc
===================================================================
--- /dev/null
+++ www/qt5-webengine/files/patch-src_3rdparty_gn_tools_gn_args.cc
@@ -0,0 +1,11 @@
+--- src/3rdparty/gn/tools/gn/args.cc.orig 2019-10-27 19:20:40.465677000 +0100
++++ src/3rdparty/gn/tools/gn/args.cc 2019-10-27 19:21:07.759511000 +0100
+@@ -332,7 +332,7 @@
+ arch = kMips64;
+ else if (os_arch == "s390x")
+ arch = kS390X;
+- else if (os_arch == "ppc64" || os_arch == "ppc64le")
++ else if (os_arch == "ppc64" || os_arch == "ppc64le" || os_arch == "powerpc")
+ // We handle the endianness inside //build/config/host_byteorder.gni.
+ // This allows us to use the same toolchain as ppc64 BE
+ // and specific flags are included using the host_byteorder logic.
Index: www/qt5-webengine/pkg-plist
===================================================================
--- www/qt5-webengine/pkg-plist
+++ www/qt5-webengine/pkg-plist
@@ -172,7 +172,8 @@
libdata/pkgconfig/Qt5WebEngineCore.pc
libdata/pkgconfig/Qt5WebEngineWidgets.pc
%%QT_LIBEXECDIR%%/QtWebEngineProcess
-%%QT_DATADIR%%/resources/icudtl.dat
+%%BE%%%%QT_DATADIR%%/resources/icudtb.dat
+%%LE%%%%QT_DATADIR%%/resources/icudtl.dat
%%QT_DATADIR%%/resources/qtwebengine_devtools_resources.pak
%%QT_DATADIR%%/resources/qtwebengine_resources.pak
%%QT_DATADIR%%/resources/qtwebengine_resources_100p.pak

File Metadata

Mime Type
text/plain
Expires
Wed, Jun 17, 7:53 PM (15 h, 47 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
34033648
Default Alt Text
D22184.id64135.diff (200 KB)

Event Timeline