diff --git a/dev-qt/qtwebengine/patches/qtwebengine-5.15.2.patchset b/dev-qt/qtwebengine/patches/qtwebengine-5.15.2.patchset index 5900c1b3b..4e534efb5 100644 --- a/dev-qt/qtwebengine/patches/qtwebengine-5.15.2.patchset +++ b/dev-qt/qtwebengine/patches/qtwebengine-5.15.2.patchset @@ -1,4 +1,4 @@ -From bac19a554984dc2be7c7173917835f0e488efa5a Mon Sep 17 00:00:00 2001 +From fa1a1a2a459628ee9307a0f555570e04ad676cfb Mon Sep 17 00:00:00 2001 From: Kacper Kasper Date: Sat, 27 Apr 2019 01:09:57 +0200 Subject: base builds & More fixes @@ -2971,10 +2971,10 @@ index 0000000..82139a4 + #qtConfig(webengine-system-libsrtp: gn_args += use_system_libsrtp=true +} -- -2.30.2 +2.37.3 -From 93e009ea227f651ba5316af9a577872f529dbc21 Mon Sep 17 00:00:00 2001 +From a4ba943f55985a6ce70b69f3bf81b6800953082c Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 14:10:47 +0100 Subject: Patch from FreeBSD @@ -3365,10 +3365,10 @@ index 3b439e8..1819d7f 100644 REPACK_DIR = $$OUT_PWD/$$getConfigDir() -- -2.30.2 +2.37.3 -From 0c7b29cf8c8e415da59959a20d3e162557485a1e Mon Sep 17 00:00:00 2001 +From ed507097041193fb9870154666e3d768b9a0efe3 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 15:52:01 +0100 Subject: gn patch @@ -3562,10 +3562,10 @@ index addd7cf..74029bd 100644 #endif -- -2.30.2 +2.37.3 -From 29e4d9ca51fface0ae6ffe160f7cf29f567c4b17 Mon Sep 17 00:00:00 2001 +From 234c5a49ba045cfa99d8c2fab61d5a67d49f9bb0 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 16:39:12 +0100 Subject: Patch from FreeBSD @@ -3772,10 +3772,10 @@ index bf09d56..9ab39dc 100644 } -- -2.30.2 +2.37.3 -From 813cb0a0fb82c2940fbffdb34b2bb1c560512a92 Mon Sep 17 00:00:00 2001 +From bd096733cba7465d6a7f8cf3261e9b5b1b8e7485 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 19:04:08 +0100 Subject: boringssl patches from FreeBSD @@ -4291,10 +4291,10 @@ index 564becb..243f2cb 100644 } else if (i == 0) { return 0; -- -2.30.2 +2.37.3 -From b86f6f6f18e06de51bd2d56faede78169555c30e Mon Sep 17 00:00:00 2001 +From a02a40bcf4be5303d7ffdb05fa7af5baa4080ad2 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 19:25:32 +0100 Subject: nasm: rename float.h to floats.h, float.c to floats.c @@ -4386,10 +4386,10 @@ index 93742d8..adbf216 100644 "asm/listing.c", "asm/parser.c", -- -2.30.2 +2.37.3 -From 26f75aa0b51c6c2f920f033703830a60a1f47e56 Mon Sep 17 00:00:00 2001 +From 231f70f1e1e82bd706a768268be12f6410684d0a Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 19:27:53 +0100 Subject: Patches from FreeBSD @@ -4723,10 +4723,10 @@ index c3c4127..0d89c71 100644 # Whether the platform provides a native accessibility toolkit. has_native_accessibility = use_atk || is_win || is_mac -- -2.30.2 +2.37.3 -From 2395f100ad7204784a54b6a970b0173a0d8628d9 Mon Sep 17 00:00:00 2001 +From 26df55536a95ffe86c20b59352a0953aa8e90c37 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 19:36:57 +0100 Subject: Haiku perfetto patches based on FreeBSD @@ -5065,10 +5065,10 @@ index 734b1f7..7d24087 100644 struct { clockid_t id; -- -2.30.2 +2.37.3 -From 7b802e1dccb70ed6b16dcefc34e04b1a4aa0b8cb Mon Sep 17 00:00:00 2001 +From fc8c28d44ef232d7b7c55043a5ce3f0c92920503 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 30 Jan 2021 21:33:44 +0100 Subject: protobuf build workaround @@ -5089,10 +5089,10 @@ index f1bd85d..e126473 100644 #undef PROTOBUF_EXPORT_TEMPLATE_TEST -- -2.30.2 +2.37.3 -From 3282ce162c66415fa938c04c7ee060fd82ad6597 Mon Sep 17 00:00:00 2001 +From 97ca4de014feb2ae50000a2db3fc9827c476672d Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Sat, 6 Feb 2021 16:18:33 +0100 Subject: Haiku patches (from FreeBSD or Kasper) @@ -9444,10 +9444,10 @@ index f6d3053..2c174ea 100644 } -- -2.30.2 +2.37.3 -From 99feb25f593b97e18f1be36f63a793bbd93ee799 Mon Sep 17 00:00:00 2001 +From d886325cc2ad86f6481bc32ad17c169b3bc8ac3b Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Tue, 16 Feb 2021 20:29:26 +0100 Subject: more Haiku patches @@ -9793,10 +9793,10 @@ index f0e20fd..9595ab2 100644 ret = madvise(address, size, MADV_DONTNEED); #endif -- -2.30.2 +2.37.3 -From 0f019f6d526da000ff77c74f51bd917b38d7fec1 Mon Sep 17 00:00:00 2001 +From 2f357db8b848158309d494f6a36a9d7f1866aa7b Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Mon, 1 Mar 2021 17:46:18 +0100 Subject: Haiku: use internal certverifier like linux @@ -9838,10 +9838,10 @@ index 69d70e4..d2c4e13 100644 // depends on glib. // -- -2.30.2 +2.37.3 -From 05fdac8df5dc216489d848c016c5d1c82889766f Mon Sep 17 00:00:00 2001 +From 3c9370a94cc96e579ec5e81df41090b102738be9 Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Wed, 3 Mar 2021 16:38:32 +0100 Subject: Haiku: some more patches @@ -9882,10 +9882,10 @@ index 52dd9cd..f69b482 100644 } // namespace media -- -2.30.2 +2.37.3 -From 6b44f0c3fcd8a8ac57aa93b84fb1424e27406211 Mon Sep 17 00:00:00 2001 +From 438c56f4a557b2dc9563bdca18615f48afbc718a Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Wed, 17 Nov 2021 16:45:02 +0100 Subject: Haiku: clean up for r1beta3 @@ -9984,10 +9984,10 @@ index 9595ab2..8b06f3d 100644 ret = madvise(address, size, MADV_DONTNEED); #endif -- -2.30.2 +2.37.3 -From 2d093dd1a95000f8af93585e19a2580f0e8f6c33 Mon Sep 17 00:00:00 2001 +From 965b12d1dde4acf7e13cdfce4eb88be9e1695b9b Mon Sep 17 00:00:00 2001 From: Jerome Duval Date: Thu, 18 Nov 2021 20:23:52 +0100 Subject: gcc11 fixes @@ -10018,5 +10018,9991 @@ index 11ae91c..558ff00 100644 #include -- -2.30.2 +2.37.3 + + +From 3516e78db72d15e0e26396e03d3463eafc07c324 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Sat, 20 Nov 2021 23:47:40 +1000 +Subject: Add haiku audio backend + + +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc +new file mode 100644 +index 0000000..3e26bce +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc +@@ -0,0 +1,104 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#include "media/audio/haiku/audio_manager_haiku.h" ++ ++#include ++ ++#include "media/audio/haiku/audio_output_stream_haiku.h" ++ ++namespace media { ++ ++AudioManagerHaiku::AudioManagerHaiku( ++ std::unique_ptr audio_thread, ++ AudioLogFactory* audio_log_factory) ++ : AudioManagerBase(std::move(audio_thread), audio_log_factory) {} ++ ++AudioManagerHaiku::~AudioManagerHaiku() = default; ++ ++bool AudioManagerHaiku::HasAudioOutputDevices() { ++ return true; ++} ++ ++bool AudioManagerHaiku::HasAudioInputDevices() { ++ return true; ++} ++ ++void AudioManagerHaiku::GetAudioInputDeviceNames( ++ AudioDeviceNames* device_names) { ++ *device_names = {AudioDeviceName::CreateDefault()}; ++} ++ ++void AudioManagerHaiku::GetAudioOutputDeviceNames( ++ AudioDeviceNames* device_names) { ++ *device_names = {AudioDeviceName::CreateDefault()}; ++} ++ ++AudioParameters AudioManagerHaiku::GetInputStreamParameters( ++ const std::string& device_id) { ++ AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY, ++ CHANNEL_LAYOUT_MONO, 16000, 160); ++ params.set_effects(AudioParameters::ECHO_CANCELLER | ++ AudioParameters::NOISE_SUPPRESSION | ++ AudioParameters::AUTOMATIC_GAIN_CONTROL); ++ ++ return params; ++} ++ ++AudioParameters AudioManagerHaiku::GetPreferredOutputStreamParameters( ++ const std::string& output_device_id, ++ const AudioParameters& input_params) { ++ return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, ++ CHANNEL_LAYOUT_STEREO, 48000, 480); ++} ++ ++const char* AudioManagerHaiku::GetName() { ++ return "Haiku"; ++} ++ ++AudioOutputStream* AudioManagerHaiku::MakeLinearOutputStream( ++ const AudioParameters& params, ++ const LogCallback& log_callback) { ++ NOTREACHED(); ++ return nullptr; ++} ++ ++AudioOutputStream* AudioManagerHaiku::MakeLowLatencyOutputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) { ++ DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format()); ++ ++ if (!device_id.empty() && ++ device_id != AudioDeviceDescription::kDefaultDeviceId) { ++ return nullptr; ++ } ++ ++ return new AudioOutputStreamHaiku(this, params); ++} ++ ++AudioInputStream* AudioManagerHaiku::MakeLinearInputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) { ++ NOTREACHED(); ++ return nullptr; ++} ++ ++AudioInputStream* AudioManagerHaiku::MakeLowLatencyInputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) { ++ NOTREACHED(); ++ return nullptr; ++} ++ ++std::unique_ptr CreateAudioManager( ++ std::unique_ptr audio_thread, ++ AudioLogFactory* audio_log_factory) { ++ return std::make_unique(std::move(audio_thread), ++ audio_log_factory); ++} ++ ++} // namespace media +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.h b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.h +new file mode 100644 +index 0000000..2a3eba9 +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.h +@@ -0,0 +1,55 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef MEDIA_AUDIO_HAIKU_AUDIO_MANAGER_HAIKU_H_ ++#define MEDIA_AUDIO_HAIKU_AUDIO_MANAGER_HAIKU_H_ ++ ++#include "media/audio/audio_manager_base.h" ++ ++namespace media { ++ ++class AudioManagerHaiku : public AudioManagerBase { ++ public: ++ AudioManagerHaiku(std::unique_ptr audio_thread, ++ AudioLogFactory* audio_log_factory); ++ ~AudioManagerHaiku() override; ++ ++ // Implementation of AudioManager. ++ bool HasAudioOutputDevices() override; ++ bool HasAudioInputDevices() override; ++ void GetAudioInputDeviceNames(AudioDeviceNames* device_names) override; ++ void GetAudioOutputDeviceNames(AudioDeviceNames* device_names) override; ++ AudioParameters GetInputStreamParameters( ++ const std::string& device_id) override; ++ const char* GetName() override; ++ ++ // Implementation of AudioManagerBase. ++ AudioOutputStream* MakeLinearOutputStream( ++ const AudioParameters& params, ++ const LogCallback& log_callback) override; ++ AudioOutputStream* MakeLowLatencyOutputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) override; ++ AudioInputStream* MakeLinearInputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) override; ++ AudioInputStream* MakeLowLatencyInputStream( ++ const AudioParameters& params, ++ const std::string& device_id, ++ const LogCallback& log_callback) override; ++ ++ protected: ++ AudioParameters GetPreferredOutputStreamParameters( ++ const std::string& output_device_id, ++ const AudioParameters& input_params) override; ++ ++ private: ++ DISALLOW_COPY_AND_ASSIGN(AudioManagerHaiku); ++}; ++ ++} // namespace media ++ ++#endif // MEDIA_AUDIO_HAIKU_AUDIO_MANAGER_HAIKU_H_ +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.cc b/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.cc +new file mode 100644 +index 0000000..73c2419 +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.cc +@@ -0,0 +1,95 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#include "media/audio/haiku/audio_output_stream_haiku.h" ++ ++#include "base/bind.h" ++#include "base/fuchsia/default_context.h" ++#include "base/memory/writable_shared_memory_region.h" ++#include "media/audio/haiku/audio_manager_haiku.h" ++#include "media/base/audio_sample_types.h" ++#include "media/base/audio_timestamp_helper.h" ++ ++namespace media { ++ ++AudioOutputStreamHaiku::AudioOutputStreamHaiku( ++ AudioManagerHaiku* manager, ++ const AudioParameters& parameters) ++ : manager_(manager), ++ parameters_(parameters), ++ player_(NULL), ++ audio_bus_(AudioBus::Create(parameters)) { ++ process_name_.SetTo("QtWebEngine"); ++ app_info appInfo; ++ if (be_app->GetAppInfo(&appInfo) == B_OK) { ++ BPath path(&appInfo.ref); ++ process_name_.SetTo(path.Leaf()); ++ } ++} ++ ++AudioOutputStreamHaiku::~AudioOutputStreamHaiku() {} ++ ++bool AudioOutputStreamHaiku::Open() { ++ media_raw_audio_format format; ++ format = { ++ parameters_.sample_rate(), ++ parameters_.channels(), ++ media_raw_audio_format::B_AUDIO_FLOAT, ++ B_MEDIA_LITTLE_ENDIAN, ++ parameters_.GetBytesPerBuffer(kSampleFormatF32) ++ }; ++ ++ player_ = new BSoundPlayer(&format, process_name_.String(), audio_callback, ++ NULL, static_cast(this)); ++ ++ return true; ++} ++ ++void AudioOutputStreamHaiku::Start(AudioSourceCallback* callback) { ++ DCHECK(!callback_); ++ callback_ = callback; ++ ++ player_->Start(); ++ player_->SetHasData(true); ++} ++ ++void AudioOutputStreamHaiku::Stop() { ++ callback_ = nullptr; ++ ++ player_->SetHasData(false); ++ player_->Stop(); ++} ++ ++void AudioOutputStreamHaiku::Flush() {} ++ ++void AudioOutputStreamHaiku::SetVolume(double volume) { ++ DCHECK(0.0 <= volume && volume <= 1.0) << volume; ++ player_->SetVolume(volume); ++} ++ ++void AudioOutputStreamHaiku::GetVolume(double* volume) { ++ *volume = player_->Volume(); ++} ++ ++void AudioOutputStreamHaiku::Close() { ++ Stop(); ++ ++ delete player_; ++ ++ manager_->ReleaseOutputStream(this); ++} ++ ++void AudioOutputStreamHaiku::AudioCallback(void *stream, size_t len) noexcept ++{ ++ int frames_filled = callback_->OnMoreData(base::TimeDelta::FromMicroseconds(0), base::TimeTicks::Now(), 0, audio_bus_.get()); ++ if (frames_filled <= 0) { ++ memset(stream, 0, len); ++ return; ++ } ++ ++ audio_bus_->ToInterleaved( ++ frames_filled, reinterpret_cast(stream)); ++} ++ ++} // namespace media +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.h b/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.h +new file mode 100644 +index 0000000..0e97029 +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_output_stream_haiku.h +@@ -0,0 +1,64 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef MEDIA_AUDIO_HAIKU_AUDIO_OUTPUT_STREAM_HAIKU_H_ ++#define MEDIA_AUDIO_HAIKU_AUDIO_OUTPUT_STREAM_HAIKU_H_ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#include "base/memory/shared_memory_mapping.h" ++#include "base/optional.h" ++#include "base/timer/timer.h" ++#include "media/audio/audio_io.h" ++#include "media/base/audio_parameters.h" ++ ++namespace media { ++ ++class AudioManagerHaiku; ++ ++class AudioOutputStreamHaiku : public AudioOutputStream { ++ public: ++ // Caller must ensure that manager outlives the stream. ++ AudioOutputStreamHaiku(AudioManagerHaiku* manager, ++ const AudioParameters& parameters); ++ ++ // AudioOutputStream interface. ++ bool Open() override; ++ void Start(AudioSourceCallback* callback) override; ++ void Stop() override; ++ void Flush() override; ++ void SetVolume(double volume) override; ++ void GetVolume(double* volume) override; ++ void Close() override; ++ ++ private: ++ ~AudioOutputStreamHaiku() override; ++ ++ AudioManagerHaiku* manager_; ++ AudioParameters parameters_; ++ ++ BSoundPlayer *player_; ++ BString process_name_; ++ ++ std::unique_ptr audio_bus_; ++ ++ void AudioCallback(void *stream, size_t len) noexcept; ++ static void audio_callback(void *cookie, void *buffer, size_t len, const media_raw_audio_format &) noexcept { ++ static_cast(cookie)->AudioCallback(buffer, len); ++ } ++ ++ AudioSourceCallback* callback_ = nullptr; ++ ++ DISALLOW_COPY_AND_ASSIGN(AudioOutputStreamHaiku); ++}; ++ ++} // namespace media ++ ++#endif // MEDIA_AUDIO_HAIKU_AUDIO_OUTPUT_STREAM_HAIKU_H_ +-- +2.37.3 + + +From 13b759fe8113536c09a1801bd96826825bf44fe4 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Sat, 20 Nov 2021 23:52:06 +1000 +Subject: Enable build for haiku audio backend + + +diff --git a/src/3rdparty/chromium/media/audio/BUILD.gn b/src/3rdparty/chromium/media/audio/BUILD.gn +index 092b002..f4f4c4c 100644 +--- a/src/3rdparty/chromium/media/audio/BUILD.gn ++++ b/src/3rdparty/chromium/media/audio/BUILD.gn +@@ -230,7 +230,7 @@ source_set("audio") { + ] + } + +- if (is_linux) { ++ if (is_linux && !is_haiku) { + sources += [ "linux/audio_manager_linux.cc" ] + } + +@@ -297,6 +297,19 @@ source_set("audio") { + ] + } + ++ if (is_haiku) { ++ sources += [ ++ "haiku/audio_manager_haiku.cc", ++ "haiku/audio_manager_haiku.h", ++ "haiku/audio_output_stream_haiku.cc", ++ "haiku/audio_output_stream_haiku.h", ++ ] ++ libs += [ ++ "be", ++ "media", ++ ] ++ } ++ + if (enable_webrtc) { + sources += [ + "audio_input_stream_data_interceptor.cc", +-- +2.37.3 + + +From ac3a788de8bb6690f6d26050cc07bd209461459a Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Sun, 21 Nov 2021 21:46:52 +1000 +Subject: Fix build openh264 + + +diff --git a/src/3rdparty/chromium/third_party/openh264/src/codec/common/src/WelsThreadLib.cpp b/src/3rdparty/chromium/third_party/openh264/src/codec/common/src/WelsThreadLib.cpp +index 4477e34..cfb6a01 100644 +--- a/src/3rdparty/chromium/third_party/openh264/src/codec/common/src/WelsThreadLib.cpp ++++ b/src/3rdparty/chromium/third_party/openh264/src/codec/common/src/WelsThreadLib.cpp +@@ -48,7 +48,7 @@ + #include + #include + #include +-#ifndef __Fuchsia__ ++#if !defined(__Fuchsia__) && !defined(__HAIKU__) + #include + #endif + #ifdef __APPLE__ +@@ -63,6 +63,9 @@ + #ifdef __ANDROID__ + #include + #endif ++#ifdef __HAIKU__ ++#include ++#endif + + #include "WelsThreadLib.h" + #include +@@ -232,7 +235,7 @@ WELS_THREAD_ERROR_CODE WelsThreadCreate (WELS_THREAD_HANDLE* thread, LPWELS_ + err = pthread_attr_init (&at); + if (err) + return err; +-#if !defined(__ANDROID__) && !defined(__Fuchsia__) ++#if !defined(__ANDROID__) && !defined(__Fuchsia__) && !defined(__HAIKU__) + err = pthread_attr_setscope (&at, PTHREAD_SCOPE_SYSTEM); + if (err) + return err; +@@ -511,6 +514,13 @@ WELS_THREAD_ERROR_CODE WelsQueryLogicalProcessInfo (WelsLogicalProcessInfo* p + pInfo->ProcessorCount = 1; + return WELS_THREAD_ERROR_OK; + ++#elif defined(__HAIKU__) ++ ++ system_info info; ++ get_system_info(&info); ++ pInfo->ProcessorCount = info.cpu_count; ++ return WELS_THREAD_ERROR_OK; ++ + #elif defined(__Fuchsia__) + + pInfo->ProcessorCount = sysconf(_SC_NPROCESSORS_ONLN); +-- +2.37.3 + + +From 14ebb458ee5213473e0f6686ff75232455409586 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Wed, 24 Nov 2021 16:53:34 +1000 +Subject: Add microphone support for haiku audio backend + + +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.cc b/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.cc +new file mode 100644 +index 0000000..944023f +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.cc +@@ -0,0 +1,309 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#include "media/audio/haiku/audio_input_stream_haiku.h" ++ ++#include "base/logging.h" ++#include "media/audio/audio_device_description.h" ++#include "media/audio/haiku/audio_manager_haiku.h" ++ ++namespace media { ++ ++const int kNumberOfBlocksBufferInFifo = 2; ++ ++HaikuAudioRecorder::HaikuAudioRecorder(const char *node_name) ++ : node_name_(node_name) { ++ if (node_name == NULL) { ++ node_name_.SetTo("QtWebEngine"); ++ app_info appInfo; ++ if (be_app->GetAppInfo(&appInfo) == B_OK) { ++ BPath path(&appInfo.ref); ++ node_name_.SetTo(path.Leaf()); ++ } ++ } ++ status_t error; ++ media_roster_ = BMediaRoster::Roster(&error); ++ if (error == B_OK) ++ is_inited_ = true; ++} ++ ++HaikuAudioRecorder::~HaikuAudioRecorder() { ++ Close(); ++} ++ ++bool HaikuAudioRecorder::SetCallbacks(BMediaRecorder::ProcessFunc record_func, ++ BMediaRecorder::NotifyFunc notify_func, void* cookie) { ++ if (recorder_->SetHooks(record_func, notify_func, cookie) < B_OK) { ++ recorder_->SetHooks(NULL, NULL, NULL); ++ return false; ++ } ++ return true; ++} ++ ++bool HaikuAudioRecorder::Open() { ++ if (!is_inited_ || is_opened_) ++ return false; ++ ++ status_t error; ++ ++ error = media_roster_->GetAudioInput(&audio_input_node_); ++ if (error < B_OK) ++ return false; ++ ++ error = media_roster_->GetAudioMixer(&audio_mixer_node_); ++ if (error < B_OK) ++ return false; ++ ++ recorder_ = new BMediaRecorder(node_name_, B_MEDIA_RAW_AUDIO); ++ if (recorder_->InitCheck() < B_OK) { ++ delete recorder_; ++ recorder_ = nullptr; ++ return false; ++ } ++ ++ media_format output_format; ++ output_format.type = B_MEDIA_RAW_AUDIO; ++ output_format.u.raw_audio = media_raw_audio_format::wildcard; ++ recorder_->SetAcceptedFormat(output_format); ++ ++ const int maxInputCount = 64; ++ dormant_node_info dni[maxInputCount]; ++ ++ int32 real_count = maxInputCount; ++ ++ error = media_roster_->GetDormantNodes(dni, &real_count, 0, &output_format, ++ 0, B_BUFFER_PRODUCER | B_PHYSICAL_INPUT); ++ if (real_count > maxInputCount) ++ real_count = maxInputCount; ++ char selected_name[B_MEDIA_NAME_LENGTH] = "Default input"; ++ ++ for (int i = 0; i < real_count; i++) { ++ media_node_id ni[12]; ++ int32 ni_count = 12; ++ error = media_roster_->GetInstancesFor(dni[i].addon, dni[i].flavor_id, ni, &ni_count); ++ if (error == B_OK) { ++ for (int j = 0; j < ni_count; j++) { ++ if (ni[j] == audio_input_node_.node) { ++ strcpy(selected_name, dni[i].name); ++ break; ++ } ++ } ++ } ++ } ++ ++ if (!recorder_->IsConnected()) { ++ int32 count = 0; ++ error = media_roster_->GetFreeOutputsFor(audio_input_node_, ++ &audio_output_, 1, &count, B_MEDIA_RAW_AUDIO); ++ if (error < B_OK || count < 1) { ++ delete recorder_; ++ recorder_ = nullptr; ++ return false; ++ } ++ ++ record_format_.u.raw_audio = audio_output_.format.u.raw_audio; ++ } else { ++ record_format_.u.raw_audio = recorder_->AcceptedFormat().u.raw_audio; ++ } ++ ++ record_format_.type = B_MEDIA_RAW_AUDIO; ++ ++ is_opened_ = true; ++ ++ return true; ++} ++ ++void HaikuAudioRecorder::Close() { ++ if (!is_opened_) ++ return; ++ is_opened_ = false; ++ ++ if (is_recording_) ++ Stop(); ++ ++ if (recorder_) ++ delete recorder_; ++ ++ recorder_ = nullptr; ++} ++ ++void HaikuAudioRecorder::Start() { ++ if (recorder_ == NULL || !is_inited_ || is_recording_) ++ return; ++ ++ if (!recorder_->IsConnected()) { ++ if (recorder_->Connect(audio_input_node_, &audio_output_, &record_format_) < B_OK) { ++ recorder_->SetHooks(NULL, NULL, NULL); ++ return; ++ } ++ } ++ ++ is_recording_ = true; ++ recorder_->Start(); ++} ++ ++void HaikuAudioRecorder::Stop() { ++ is_recording_ = false; ++ ++ if (recorder_->IsConnected()) ++ recorder_->Disconnect(); ++ ++ recorder_->Stop(); ++} ++ ++base::TimeDelta HaikuAudioRecorder::Latency() { ++ bigtime_t latency; ++ if (media_roster_->GetLatencyFor(audio_input_node_, &latency) == B_OK && is_recording_) ++ return base::TimeDelta::FromMicroseconds(latency); ++ return base::TimeDelta::FromMicroseconds(0); ++} ++ ++SampleFormat HaikuAudioRecorder::Format() { ++ SampleFormat sample_format = kUnknownSampleFormat; ++ ++ switch(record_format_.u.raw_audio.format) { ++ case media_raw_audio_format::B_AUDIO_UCHAR: ++ sample_format = kSampleFormatU8; ++ break; ++ case media_raw_audio_format::B_AUDIO_SHORT: ++ sample_format = kSampleFormatS16; ++ break; ++ case media_raw_audio_format::B_AUDIO_INT: ++ sample_format = kSampleFormatS32; ++ break; ++ case media_raw_audio_format::B_AUDIO_FLOAT: ++ sample_format = kSampleFormatF32; ++ break; ++ } ++ return sample_format; ++} ++ ++ChannelLayout HaikuAudioRecorder::Channels() { ++ ChannelLayout layout = CHANNEL_LAYOUT_UNSUPPORTED; ++ ++ switch(record_format_.u.raw_audio.channel_count) { ++ case 1: ++ layout = CHANNEL_LAYOUT_MONO; ++ break; ++ case 2: ++ layout = CHANNEL_LAYOUT_STEREO; ++ break; ++ } ++ ++ return layout; ++} ++ ++ ++AudioInputStreamHaiku::AudioInputStreamHaiku( ++ AudioManagerHaiku* manager, ++ const AudioParameters& parameters) ++ : manager_(manager), ++ parameters_(parameters), ++ recorder_(new HaikuAudioRecorder()), ++ callback_(nullptr), ++ fifo_(parameters.channels(), ++ parameters.frames_per_buffer(), ++ kNumberOfBlocksBufferInFifo), ++ audio_bus_(media::AudioBus::Create(parameters)) { ++} ++ ++AudioInputStreamHaiku::~AudioInputStreamHaiku() { ++ delete recorder_; ++} ++ ++bool AudioInputStreamHaiku::Open() { ++ return recorder_->Open(); ++} ++ ++void AudioInputStreamHaiku::Start(AudioInputCallback* callback) { ++ callback_ = callback; ++ if (!recorder_->IsOpened() || recorder_->IsRecording()) ++ return; ++ ++ if (!recorder_->SetCallbacks(_read_callback, NULL, this)) { ++ recorder_->Close(); ++ return; ++ } ++ ++ StartAgc(); ++ recorder_->Start(); ++} ++ ++void AudioInputStreamHaiku::Stop() { ++ StopAgc(); ++ recorder_->Stop(); ++ fifo_.Clear(); ++} ++ ++void AudioInputStreamHaiku::Close() { ++ recorder_->Close(); ++ manager_->ReleaseInputStream(this); ++} ++ ++double AudioInputStreamHaiku::GetMaxVolume() { ++ return 1.0; ++} ++ ++void AudioInputStreamHaiku::SetVolume(double volume) { ++ UpdateAgcVolume(); ++} ++ ++double AudioInputStreamHaiku::GetVolume() { ++ return 1.0; ++} ++ ++bool AudioInputStreamHaiku::SetAutomaticGainControl(bool enabled) { ++ return false; ++} ++ ++bool AudioInputStreamHaiku::GetAutomaticGainControl() { ++ return false; ++} ++ ++bool AudioInputStreamHaiku::IsMuted() { ++ return false; ++} ++ ++void AudioInputStreamHaiku::SetOutputDeviceForAec( ++ const std::string& output_device_id) { ++} ++ ++void AudioInputStreamHaiku::ReadCallback(void* buffer, size_t size, ++ const media_format &format) noexcept ++{ ++ double normalized_volume = 0.0; ++ GetAgcVolume(&normalized_volume); ++ ++ SampleFormat sample_format = recorder_->Format(); ++ ++ base::TimeTicks capture_time = ++ base::TimeTicks::Now() - (recorder_->Latency() + ++ AudioTimestampHelper::FramesToTime(fifo_.GetAvailableFrames(), ++ parameters_.sample_rate())); ++ ++ const int number_of_frames = size / parameters_.GetBytesPerFrame(sample_format); ++ ++ if (number_of_frames > fifo_.GetUnfilledFrames()) { ++ const int increase_blocks_of_buffer = ++ static_cast((number_of_frames - fifo_.GetUnfilledFrames()) / ++ parameters_.frames_per_buffer()) + 1; ++ fifo_.IncreaseCapacity(increase_blocks_of_buffer); ++ } ++ ++ fifo_.Push(buffer, number_of_frames, SampleFormatToBytesPerChannel(sample_format)); ++ ++ while (fifo_.available_blocks()) { ++ const AudioBus* audio_bus = fifo_.Consume(); ++ ++ callback_->OnData(audio_bus, capture_time, normalized_volume); ++ ++ capture_time += AudioTimestampHelper::FramesToTime(audio_bus->frames(), ++ parameters_.sample_rate()); ++ ++ if (fifo_.available_blocks()) ++ base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(5)); ++ } ++} ++ ++} // namespace media +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.h b/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.h +new file mode 100644 +index 0000000..2cd96dc +--- /dev/null ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_input_stream_haiku.h +@@ -0,0 +1,112 @@ ++// Copyright 2021 Gerasim Troeglazov. All rights reserved. ++// Use of this source code is governed by a BSD-style license that can be ++// found in the LICENSE file. ++ ++#ifndef MEDIA_AUDIO_HAIKU_AUDIO_INPUT_STREAM_HAIKU_H_ ++#define MEDIA_AUDIO_HAIKU_AUDIO_INPUT_STREAM_HAIKU_H_ ++ ++#include "media/audio/audio_io.h" ++#include "media/audio/agc_audio_stream.h" ++#include "media/base/audio_block_fifo.h" ++#include "media/base/audio_parameters.h" ++#include "media/base/audio_timestamp_helper.h" ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++namespace media { ++ ++class AudioManagerHaiku; ++ ++class HaikuAudioRecorder { ++public: ++ HaikuAudioRecorder(const char *node_name = NULL); ++ ~HaikuAudioRecorder(); ++ ++ bool SetCallbacks(BMediaRecorder::ProcessFunc recordFunc = NULL, ++ BMediaRecorder::NotifyFunc notifyFunc = NULL, ++ void* cookie = NULL); ++ ++ bool Open(); ++ void Close(); ++ void Start(); ++ void Stop(); ++ ++ base::TimeDelta Latency(); ++ BMediaRoster *MediaRoster() { return media_roster_; } ++ ++ SampleFormat Format(); ++ ChannelLayout Channels(); ++ int SampleRate() { return static_cast(record_format_.u.raw_audio.frame_rate); } ++ ++ bool IsOpened() { return is_opened_; } ++ bool IsRecording() { return is_recording_; } ++ bool InitCheck() { return is_inited_; } ++ ++private: ++ BString node_name_; ++ ++ BMediaRoster *media_roster_{0u}; ++ BMediaRecorder *recorder_{0u}; ++ ++ media_format record_format_; ++ media_node audio_input_node_; ++ media_node audio_mixer_node_; ++ media_output audio_output_; ++ ++ bool is_inited_{false}; ++ bool is_opened_{false}; ++ bool is_recording_{false}; ++}; ++ ++ ++class AudioInputStreamHaiku : public AgcAudioStream { ++ public: ++ AudioInputStreamHaiku(AudioManagerHaiku* manager, ++ const AudioParameters& parameters); ++ ~AudioInputStreamHaiku() override; ++ ++ bool Open() override; ++ void Start(AudioInputCallback* callback) override; ++ void Stop() override; ++ void Close() override; ++ double GetMaxVolume() override; ++ void SetVolume(double volume) override; ++ double GetVolume() override; ++ bool SetAutomaticGainControl(bool enabled) override; ++ bool GetAutomaticGainControl() override; ++ bool IsMuted() override; ++ void SetOutputDeviceForAec(const std::string& output_device_id) override; ++ ++ void ReadCallback(void* data, size_t size, const media_format &format) noexcept; ++ ++ private: ++ static void _read_callback(void* cookie, bigtime_t, void* data, size_t size, const media_format &format) noexcept { ++ return static_cast(cookie)->ReadCallback(data, size, format); ++ } ++ ++ AudioManagerHaiku* const manager_; ++ AudioParameters parameters_; ++ HaikuAudioRecorder* recorder_; ++ AudioInputCallback* callback_; ++ AudioBlockFifo fifo_; ++ ++ std::unique_ptr audio_bus_; ++ ++ DISALLOW_COPY_AND_ASSIGN(AudioInputStreamHaiku); ++}; ++ ++} // namespace media ++ ++#endif // MEDIA_AUDIO_HAIKU_AUDIO_INPUT_STREAM_HAIKU_H_ +-- +2.37.3 + + +From e232505daeb943e39deb63c6db1d2402c42e8358 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Wed, 24 Nov 2021 16:55:00 +1000 +Subject: Add haiku audio input to build + + +diff --git a/src/3rdparty/chromium/media/audio/BUILD.gn b/src/3rdparty/chromium/media/audio/BUILD.gn +index f4f4c4c..1c7158c 100644 +--- a/src/3rdparty/chromium/media/audio/BUILD.gn ++++ b/src/3rdparty/chromium/media/audio/BUILD.gn +@@ -299,6 +299,8 @@ source_set("audio") { + + if (is_haiku) { + sources += [ ++ "haiku/audio_input_stream_haiku.cc", ++ "haiku/audio_input_stream_haiku.h", + "haiku/audio_manager_haiku.cc", + "haiku/audio_manager_haiku.h", + "haiku/audio_output_stream_haiku.cc", +-- +2.37.3 + + +From cc47560b7b7982e6bd547b0fbb9eaa1a5d8e0c15 Mon Sep 17 00:00:00 2001 +From: Gerasim Troeglazov <3dEyes@gmail.com> +Date: Wed, 24 Nov 2021 16:56:15 +1000 +Subject: Add haiku audio input to audio manager + + +diff --git a/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc +index 3e26bce..186319c 100644 +--- a/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc ++++ b/src/3rdparty/chromium/media/audio/haiku/audio_manager_haiku.cc +@@ -6,6 +6,7 @@ + + #include + ++#include "media/audio/haiku/audio_input_stream_haiku.h" + #include "media/audio/haiku/audio_output_stream_haiku.h" + + namespace media { +@@ -37,13 +38,17 @@ void AudioManagerHaiku::GetAudioOutputDeviceNames( + + AudioParameters AudioManagerHaiku::GetInputStreamParameters( + const std::string& device_id) { +- AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY, +- CHANNEL_LAYOUT_MONO, 16000, 160); +- params.set_effects(AudioParameters::ECHO_CANCELLER | +- AudioParameters::NOISE_SUPPRESSION | +- AudioParameters::AUTOMATIC_GAIN_CONTROL); ++ HaikuAudioRecorder recorder; ++ if (recorder.Open()) { ++ AudioParameters params(AudioParameters::AUDIO_PCM_LOW_LATENCY, ++ recorder.Channels(), recorder.SampleRate(), ++ recorder.SampleRate() / 100); ++ params.set_effects(AudioParameters::NO_EFFECTS); ++ return params; ++ } + +- return params; ++ return AudioParameters(AudioParameters::AUDIO_PCM_LOW_LATENCY, ++ CHANNEL_LAYOUT_STEREO, 48000, 480); + } + + AudioParameters AudioManagerHaiku::GetPreferredOutputStreamParameters( +@@ -60,8 +65,8 @@ const char* AudioManagerHaiku::GetName() { + AudioOutputStream* AudioManagerHaiku::MakeLinearOutputStream( + const AudioParameters& params, + const LogCallback& log_callback) { +- NOTREACHED(); +- return nullptr; ++ DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format()); ++ return new AudioOutputStreamHaiku(this, params); + } + + AudioOutputStream* AudioManagerHaiku::MakeLowLatencyOutputStream( +@@ -69,12 +74,6 @@ AudioOutputStream* AudioManagerHaiku::MakeLowLatencyOutputStream( + const std::string& device_id, + const LogCallback& log_callback) { + DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format()); +- +- if (!device_id.empty() && +- device_id != AudioDeviceDescription::kDefaultDeviceId) { +- return nullptr; +- } +- + return new AudioOutputStreamHaiku(this, params); + } + +@@ -82,16 +81,16 @@ AudioInputStream* AudioManagerHaiku::MakeLinearInputStream( + const AudioParameters& params, + const std::string& device_id, + const LogCallback& log_callback) { +- NOTREACHED(); +- return nullptr; ++ DCHECK_EQ(AudioParameters::AUDIO_PCM_LINEAR, params.format()); ++ return new AudioInputStreamHaiku(this, params); + } + + AudioInputStream* AudioManagerHaiku::MakeLowLatencyInputStream( + const AudioParameters& params, + const std::string& device_id, + const LogCallback& log_callback) { +- NOTREACHED(); +- return nullptr; ++ DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format()); ++ return new AudioInputStreamHaiku(this, params); + } + + std::unique_ptr CreateAudioManager( +-- +2.37.3 + + +From c3c65f34a68ae6636237bcde25c57081095f1d82 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Duval?= +Date: Sat, 4 Nov 2023 21:17:55 +0100 +Subject: missing patches from FreeBSD, adapted for Haiku + + +diff --git a/src/3rdparty/chromium/base/allocator/allocator_shim.cc b/src/3rdparty/chromium/base/allocator/allocator_shim.cc +index ef42d5a..2495de3 100644 +--- a/src/3rdparty/chromium/base/allocator/allocator_shim.cc ++++ b/src/3rdparty/chromium/base/allocator/allocator_shim.cc +@@ -71,7 +71,7 @@ inline const base::allocator::AllocatorDispatch* GetChainHead() { + // Unfortunately due to that bug NoBarrier_Load() is mistakenly fully + // barriered on Linux+Clang, and that causes visible perf regressons. + return reinterpret_cast( +-#if defined(OS_LINUX) && defined(__clang__) ++#if (defined(OS_HAIKU) || defined(OS_LINUX)) && defined(__clang__) + *static_cast(&g_chain_head) + #else + base::subtle::NoBarrier_Load(&g_chain_head) +diff --git a/src/3rdparty/chromium/base/allocator/allocator_shim_default_dispatch_to_glibc.cc b/src/3rdparty/chromium/base/allocator/allocator_shim_default_dispatch_to_glibc.cc +index 6c4ee21..4c65711 100644 +--- a/src/3rdparty/chromium/base/allocator/allocator_shim_default_dispatch_to_glibc.cc ++++ b/src/3rdparty/chromium/base/allocator/allocator_shim_default_dispatch_to_glibc.cc +@@ -6,18 +6,28 @@ + #include "base/compiler_specific.h" + + #include +-#include ++#include ++#include ++#include + + // This translation unit defines a default dispatch for the allocator shim which + // routes allocations to libc functions. +-// The code here is strongly inspired from tcmalloc's libc_override_glibc.h. ++// The code here is strongly inspired from tcmalloc's override_glibc.h. + + extern "C" { +-void* __libc_malloc(size_t size); +-void* __libc_calloc(size_t n, size_t size); +-void* __libc_realloc(void* address, size_t size); +-void* __libc_memalign(size_t alignment, size_t size); +-void __libc_free(void* ptr); ++void* __malloc(size_t size); ++void* __calloc(size_t n, size_t size); ++void* __realloc(void* address, size_t len); ++void* __memalign(size_t alignment, size_t size) { ++ void *ret; ++ if (__posix_memalign(&ret, alignment, size) != 0) { ++ return nullptr; ++ } else { ++ return ret; ++ } ++} ++int __posix_memalign(void **ptr, size_t alignment, size_t size); ++void __free(void* ptr); + } // extern "C" + + namespace { +@@ -25,32 +35,32 @@ namespace { + using base::allocator::AllocatorDispatch; + + void* GlibcMalloc(const AllocatorDispatch*, size_t size, void* context) { +- return __libc_malloc(size); ++ return __malloc(size); + } + + void* GlibcCalloc(const AllocatorDispatch*, + size_t n, + size_t size, + void* context) { +- return __libc_calloc(n, size); ++ return __calloc(n, size); + } + + void* GlibcRealloc(const AllocatorDispatch*, + void* address, + size_t size, + void* context) { +- return __libc_realloc(address, size); ++ return __realloc(address, size); + } + + void* GlibcMemalign(const AllocatorDispatch*, + size_t alignment, + size_t size, + void* context) { +- return __libc_memalign(alignment, size); ++ return __memalign(alignment, size); + } + + void GlibcFree(const AllocatorDispatch*, void* address, void* context) { +- __libc_free(address); ++ __free(address); + } + + NO_SANITIZE("cfi-icall") +diff --git a/src/3rdparty/chromium/base/allocator/allocator_shim_override_libc_symbols.h b/src/3rdparty/chromium/base/allocator/allocator_shim_override_libc_symbols.h +index cb9eeed..e1da008 100644 +--- a/src/3rdparty/chromium/base/allocator/allocator_shim_override_libc_symbols.h ++++ b/src/3rdparty/chromium/base/allocator/allocator_shim_override_libc_symbols.h +@@ -10,7 +10,7 @@ + #endif + #define BASE_ALLOCATOR_ALLOCATOR_SHIM_OVERRIDE_LIBC_SYMBOLS_H_ + +-#include ++#include + + #include "base/allocator/allocator_shim_internals.h" + +diff --git a/src/3rdparty/chromium/base/allocator/allocator_shim_unittest.cc b/src/3rdparty/chromium/base/allocator/allocator_shim_unittest.cc +index be42d81..9deed6a 100644 +--- a/src/3rdparty/chromium/base/allocator/allocator_shim_unittest.cc ++++ b/src/3rdparty/chromium/base/allocator/allocator_shim_unittest.cc +@@ -30,7 +30,7 @@ + #include "base/allocator/allocator_interception_mac.h" + #include "base/mac/mac_util.h" + #include "third_party/apple_apsl/malloc.h" +-#else ++#elif !defined(OS_HAIKU) + #include + #endif + +@@ -348,7 +348,7 @@ TEST_F(AllocatorShimTest, InterceptLibcSymbols) { + ASSERT_GE(aligned_allocs_intercepted_by_size[61], 1u); + #endif // !OS_WIN + +-#if !defined(OS_WIN) && !defined(OS_MACOSX) ++#if !defined(OS_WIN) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + void* memalign_ptr = memalign(128, 53); + ASSERT_NE(nullptr, memalign_ptr); + ASSERT_EQ(0u, reinterpret_cast(memalign_ptr) % 128); +@@ -361,7 +361,7 @@ TEST_F(AllocatorShimTest, InterceptLibcSymbols) { + ASSERT_GE(aligned_allocs_intercepted_by_alignment[kPageSize], 1u); + // pvalloc rounds the size up to the next page. + ASSERT_GE(aligned_allocs_intercepted_by_size[kPageSize], 1u); +-#endif // !OS_WIN && !OS_MACOSX ++#endif // !OS_WIN && !OS_MACOSX && !OS_HAIKU + + char* realloc_ptr = static_cast(malloc(10)); + strcpy(realloc_ptr, "foobar"); +@@ -377,13 +377,13 @@ TEST_F(AllocatorShimTest, InterceptLibcSymbols) { + free(zero_alloc_ptr); + ASSERT_GE(frees_intercepted_by_addr[Hash(zero_alloc_ptr)], 1u); + +-#if !defined(OS_WIN) && !defined(OS_MACOSX) ++#if !defined(OS_WIN) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + free(memalign_ptr); + ASSERT_GE(frees_intercepted_by_addr[Hash(memalign_ptr)], 1u); + + free(pvalloc_ptr); + ASSERT_GE(frees_intercepted_by_addr[Hash(pvalloc_ptr)], 1u); +-#endif // !OS_WIN && !OS_MACOSX ++#endif // !OS_WIN && !OS_MACOSX && !OS_HAIKU + + #if !defined(OS_WIN) + free(posix_memalign_ptr); +diff --git a/src/3rdparty/chromium/base/base_switches.cc b/src/3rdparty/chromium/base/base_switches.cc +index 6a47487..e53ef1d 100644 +--- a/src/3rdparty/chromium/base/base_switches.cc ++++ b/src/3rdparty/chromium/base/base_switches.cc +@@ -117,7 +117,7 @@ const char kDisableHighResTimer[] = "disable-highres-timer"; + const char kDisableUsbKeyboardDetect[] = "disable-usb-keyboard-detect"; + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + // The /dev/shm partition is too small in certain VM environments, causing + // Chrome to fail or crash (see http://crbug.com/715363). Use this flag to + // work-around this issue (a temporary directory will always be used to create +@@ -138,7 +138,7 @@ const char kEnableCrashReporterForTesting[] = + const char kEnableReachedCodeProfiler[] = "enable-reached-code-profiler"; + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Controls whether or not retired instruction counts are surfaced for threads + // in trace events on Linux. + // +diff --git a/src/3rdparty/chromium/base/base_switches.h b/src/3rdparty/chromium/base/base_switches.h +index b1923ef..9687878 100644 +--- a/src/3rdparty/chromium/base/base_switches.h ++++ b/src/3rdparty/chromium/base/base_switches.h +@@ -38,7 +38,7 @@ extern const char kDisableHighResTimer[]; + extern const char kDisableUsbKeyboardDetect[]; + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + extern const char kDisableDevShmUsage[]; + #endif + +@@ -51,7 +51,7 @@ extern const char kEnableReachedCodeProfiler[]; + extern const char kOrderfileMemoryOptimization[]; + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + extern const char kEnableThreadInstructionCount[]; + #endif + +diff --git a/src/3rdparty/chromium/base/cpu.cc b/src/3rdparty/chromium/base/cpu.cc +index 2a571fe..95ec68c 100644 +--- a/src/3rdparty/chromium/base/cpu.cc ++++ b/src/3rdparty/chromium/base/cpu.cc +@@ -14,7 +14,7 @@ + + #include "base/stl_util.h" + +-#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX)) ++#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU)) + #include "base/files/file_util.h" + #endif + +@@ -135,7 +135,7 @@ uint64_t xgetbv(uint32_t xcr) { + + #endif // ARCH_CPU_X86_FAMILY + +-#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX)) ++#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU)) + std::string* CpuInfoBrand() { + static std::string* brand = []() { + // This function finds the value from /proc/cpuinfo under the key "model +@@ -165,7 +165,7 @@ std::string* CpuInfoBrand() { + return brand; + } + #endif // defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || +- // defined(OS_LINUX)) ++ // defined(OS_LINUX) || defined(OS_HAIKU)) + + } // namespace + +@@ -287,7 +287,7 @@ void CPU::Initialize() { + } + } + #elif defined(ARCH_CPU_ARM_FAMILY) +-#if (defined(OS_ANDROID) || defined(OS_LINUX)) ++#if (defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU)) + cpu_brand_ = *CpuInfoBrand(); + #elif defined(OS_WIN) + // Windows makes high-resolution thread timing information available in +diff --git a/src/3rdparty/chromium/base/debug/debugger_posix.cc b/src/3rdparty/chromium/base/debug/debugger_posix.cc +index 4a75177..00f418a 100644 +--- a/src/3rdparty/chromium/base/debug/debugger_posix.cc ++++ b/src/3rdparty/chromium/base/debug/debugger_posix.cc +@@ -95,7 +95,7 @@ bool BeingDebugged() { + KERN_PROC, + KERN_PROC_PID, + getpid() +-#if defined(OS_OPENBSD) ++#if defined(OS_HAIKU) + , sizeof(struct kinfo_proc), + 0 + #endif +diff --git a/src/3rdparty/chromium/base/debug/proc_maps_linux.cc b/src/3rdparty/chromium/base/debug/proc_maps_linux.cc +index 0bb44b4..ccae74f 100644 +--- a/src/3rdparty/chromium/base/debug/proc_maps_linux.cc ++++ b/src/3rdparty/chromium/base/debug/proc_maps_linux.cc +@@ -12,7 +12,7 @@ + #include "base/strings/string_split.h" + #include "build/build_config.h" + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(OS_ANDROID) + #include + #endif + +@@ -28,6 +28,11 @@ + namespace base { + namespace debug { + ++#if defined(OS_HAIKU) ++const char kProcSelfMapsPath[] = "/proc/curproc/map"; ++#else ++const char kProcSelfMapsPath[] = "/proc/self/maps"; ++ + // Scans |proc_maps| starting from |pos| returning true if the gate VMA was + // found, otherwise returns false. + static bool ContainsGateVMA(std::string* proc_maps, size_t pos) { +@@ -43,15 +48,16 @@ static bool ContainsGateVMA(std::string* proc_maps, size_t pos) { + return false; + #endif + } ++#endif + + bool ReadProcMaps(std::string* proc_maps) { + // seq_file only writes out a page-sized amount on each call. Refer to header + // file for details. + const long kReadSize = sysconf(_SC_PAGESIZE); + +- base::ScopedFD fd(HANDLE_EINTR(open("/proc/self/maps", O_RDONLY))); ++ base::ScopedFD fd(HANDLE_EINTR(open(kProcSelfMapsPath, O_RDONLY))); + if (!fd.is_valid()) { +- DPLOG(ERROR) << "Couldn't open /proc/self/maps"; ++ DPLOG(ERROR) << "Couldn't open " << kProcSelfMapsPath; + return false; + } + proc_maps->clear(); +@@ -65,7 +71,7 @@ bool ReadProcMaps(std::string* proc_maps) { + + ssize_t bytes_read = HANDLE_EINTR(read(fd.get(), buffer, kReadSize)); + if (bytes_read < 0) { +- DPLOG(ERROR) << "Couldn't read /proc/self/maps"; ++ DPLOG(ERROR) << "Couldn't read " << kProcSelfMapsPath; + proc_maps->clear(); + return false; + } +@@ -76,6 +82,7 @@ bool ReadProcMaps(std::string* proc_maps) { + if (bytes_read == 0) + break; + ++#if !defined(OS_HAIKU) + // The gate VMA is handled as a special case after seq_file has finished + // iterating through all entries in the virtual memory table. + // +@@ -86,6 +93,7 @@ bool ReadProcMaps(std::string* proc_maps) { + // Avoid this by searching for the gate VMA and breaking early. + if (ContainsGateVMA(proc_maps, pos)) + break; ++#endif + } + + return true; +@@ -114,10 +122,32 @@ bool ParseProcMaps(const std::string& input, + MappedMemoryRegion region; + const char* line = lines[i].c_str(); + char permissions[5] = {'\0'}; // Ensure NUL-terminated string. ++ int path_index = 0; ++ ++#if defined(OS_HAIKU) ++ if (lines[i].empty()) ++ continue; ++ ++ ++ char cow; ++ ++ // Format: ++ // ++ // start end resident private_resident obj perms ref_count shadow_count flags cow needs_copy type fullpath cred ruid ++ // 0x200000 0x202000 2 6 0xfffff80005be9000 r-- 3 1 0x1000 COW NC vnode /bin/cat NCH -1 ++ // ++ if (sscanf(line, "%" SCNxPTR " %" SCNxPTR " %*ld %*ld %*llx %3c %*d %*d %*x %c%*s %*s %*s %n", ++ ®ion.start, ®ion.end, permissions, &cow, &path_index) < 4) { ++ DPLOG(WARNING) << "sscanf failed for line: " << line; ++ return false; ++ } ++ ++ const char* fullpath = line + path_index; ++ const char* cred = strchr(fullpath, ' '); ++#else + uint8_t dev_major = 0; + uint8_t dev_minor = 0; + long inode = 0; +- int path_index = 0; + + // Sample format from man 5 proc: + // +@@ -133,6 +163,7 @@ bool ParseProcMaps(const std::string& input, + DPLOG(WARNING) << "sscanf failed for line: " << line; + return false; + } ++#endif + + region.permissions = 0; + +@@ -151,14 +182,31 @@ bool ParseProcMaps(const std::string& input, + else if (permissions[2] != '-') + return false; + ++#if defined(OS_HAIKU) ++ if (cow == 'C') { ++ region.permissions |= MappedMemoryRegion::PRIVATE; ++ } else if (cow != 'N') { ++ DPLOG(WARNING) << "unknown value for COW in line " << line << ": " << cow; ++ return false; ++ } ++#else + if (permissions[3] == 'p') + region.permissions |= MappedMemoryRegion::PRIVATE; + else if (permissions[3] != 's' && permissions[3] != 'S') // Shared memory. + return false; ++#endif + + // Pushing then assigning saves us a string copy. + regions.push_back(region); ++#if defined(OS_HAIKU) ++ if (cred != nullptr) { ++ regions.back().path.assign(line + path_index, cred - fullpath); ++ } else { ++ regions.back().path.assign(line + path_index); ++ } ++#else + regions.back().path.assign(line + path_index); ++#endif + } + + regions_out->swap(regions); +diff --git a/src/3rdparty/chromium/base/files/file_path_watcher.cc b/src/3rdparty/chromium/base/files/file_path_watcher.cc +index af40346..b010c72 100644 +--- a/src/3rdparty/chromium/base/files/file_path_watcher.cc ++++ b/src/3rdparty/chromium/base/files/file_path_watcher.cc +@@ -23,7 +23,7 @@ bool FilePathWatcher::RecursiveWatchAvailable() { + defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX) + return true; + #else +- // FSEvents isn't available on iOS. ++ // FSEvents isn't available on iOS and the kqueue watcher. + return false; + #endif + } +diff --git a/src/3rdparty/chromium/base/files/file_path_watcher_kqueue.h b/src/3rdparty/chromium/base/files/file_path_watcher_kqueue.h +index ef79be5..0edee3f 100644 +--- a/src/3rdparty/chromium/base/files/file_path_watcher_kqueue.h ++++ b/src/3rdparty/chromium/base/files/file_path_watcher_kqueue.h +@@ -5,6 +5,10 @@ + #ifndef BASE_FILES_FILE_PATH_WATCHER_KQUEUE_H_ + #define BASE_FILES_FILE_PATH_WATCHER_KQUEUE_H_ + ++#ifdef __FreeBSD__ ++#include ++#include ++#endif + #include + + #include +diff --git a/src/3rdparty/chromium/base/files/file_path_watcher_unittest.cc b/src/3rdparty/chromium/base/files/file_path_watcher_unittest.cc +index 75fae8f..2579da6 100644 +--- a/src/3rdparty/chromium/base/files/file_path_watcher_unittest.cc ++++ b/src/3rdparty/chromium/base/files/file_path_watcher_unittest.cc +@@ -430,7 +430,7 @@ TEST_F(FilePathWatcherTest, WatchDirectory) { + VLOG(1) << "Waiting for file1 creation"; + ASSERT_TRUE(WaitForEvents()); + +-#if !defined(OS_MACOSX) ++#if !defined(OS_MACOSX) && !defined(OS_HAIKU) + // Mac implementation does not detect files modified in a directory. + ASSERT_TRUE(WriteFile(file1, "content v2")); + VLOG(1) << "Waiting for file1 modification"; +diff --git a/src/3rdparty/chromium/base/files/file_util.h b/src/3rdparty/chromium/base/files/file_util.h +index 9c3e06b..2c89975 100644 +--- a/src/3rdparty/chromium/base/files/file_util.h ++++ b/src/3rdparty/chromium/base/files/file_util.h +@@ -519,7 +519,7 @@ BASE_EXPORT bool VerifyPathControlledByAdmin(const base::FilePath& path); + // the directory |path|, in the number of FilePath::CharType, or -1 on failure. + BASE_EXPORT int GetMaximumPathComponentLength(const base::FilePath& path); + +-#if defined(OS_LINUX) || defined(OS_AIX) ++#if defined(OS_LINUX) || defined(OS_AIX) || defined(OS_HAIKU) + // Broad categories of file systems as returned by statfs() on Linux. + enum FileSystemType { + FILE_SYSTEM_UNKNOWN, // statfs failed. +diff --git a/src/3rdparty/chromium/base/hash/sha1.cc b/src/3rdparty/chromium/base/hash/sha1.cc +index 8e9de15..120598e 100644 +--- a/src/3rdparty/chromium/base/hash/sha1.cc ++++ b/src/3rdparty/chromium/base/hash/sha1.cc +@@ -106,8 +106,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) { +@@ -153,8 +155,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) +diff --git a/src/3rdparty/chromium/base/i18n/icu_util.cc b/src/3rdparty/chromium/base/i18n/icu_util.cc +index 3376956..dbce2a6 100644 +--- a/src/3rdparty/chromium/base/i18n/icu_util.cc ++++ b/src/3rdparty/chromium/base/i18n/icu_util.cc +@@ -49,7 +49,7 @@ + #endif + + #if defined(OS_ANDROID) || defined(OS_FUCHSIA) || \ +- (defined(OS_LINUX) && !BUILDFLAG(IS_CHROMECAST)) ++ (defined(OS_LINUX) && !BUILDFLAG(IS_CHROMECAST)) || defined(OS_HAIKU) + #include "third_party/icu/source/i18n/unicode/timezone.h" + #endif + +@@ -345,7 +345,7 @@ void InitializeIcuTimeZone() { + fuchsia::IntlProfileWatcher::GetPrimaryTimeZoneIdForIcuInitialization(); + icu::TimeZone::adoptDefault( + icu::TimeZone::createTimeZone(icu::UnicodeString::fromUTF8(zone_id))); +-#elif defined(OS_LINUX) && !BUILDFLAG(IS_CHROMECAST) ++#elif (defined(OS_LINUX) || defined(OS_HAIKU)) && !BUILDFLAG(IS_CHROMECAST) + // To respond to the time zone change properly, the default time zone + // cache in ICU has to be populated on starting up. + // See TimeZoneMonitorLinux::NotifyClientsFromImpl(). +diff --git a/src/3rdparty/chromium/base/linux_util.cc b/src/3rdparty/chromium/base/linux_util.cc +index 321234b..593885c 100644 +--- a/src/3rdparty/chromium/base/linux_util.cc ++++ b/src/3rdparty/chromium/base/linux_util.cc +@@ -78,6 +78,9 @@ class DistroNameGetter { + public: + DistroNameGetter() { + static const char* const kFilesToCheck[] = {"/etc/os-release", ++#if defined(OS_HAIKU) ++ "%%LOCALBASE%%/etc/os-release", ++#endif + "/usr/lib/os-release"}; + for (const char* file : kFilesToCheck) { + if (ReadDistroFromOSReleaseFile(file)) +diff --git a/src/3rdparty/chromium/base/logging_unittest.cc b/src/3rdparty/chromium/base/logging_unittest.cc +index 4874f8e..f4c3f0f 100644 +--- a/src/3rdparty/chromium/base/logging_unittest.cc ++++ b/src/3rdparty/chromium/base/logging_unittest.cc +@@ -591,10 +591,10 @@ void CheckCrashTestSighandler(int, siginfo_t* info, void* context_ptr) { + // need the arch-specific boilerplate below, which is inspired by breakpad. + // At the same time, on OSX, ucontext.h is deprecated but si_addr works fine. + uintptr_t crash_addr = 0; +-#if defined(OS_MACOSX) ++#if defined(OS_MACOSX) || defined(OS_HAIKU) + crash_addr = reinterpret_cast(info->si_addr); + #else // OS_POSIX && !OS_MACOSX +- ucontext_t* context = reinterpret_cast(context_ptr); ++ struct ucontext_t* context = reinterpret_cast(context_ptr); + #if defined(ARCH_CPU_X86) + crash_addr = static_cast(context->uc_mcontext.gregs[REG_EIP]); + #elif defined(ARCH_CPU_X86_64) +diff --git a/src/3rdparty/chromium/base/memory/discardable_memory.cc b/src/3rdparty/chromium/base/memory/discardable_memory.cc +index b41c27e..089eadf 100644 +--- a/src/3rdparty/chromium/base/memory/discardable_memory.cc ++++ b/src/3rdparty/chromium/base/memory/discardable_memory.cc +@@ -23,7 +23,7 @@ const base::Feature kMadvFreeDiscardableMemory{ + "MadvFreeDiscardableMemory", base::FEATURE_DISABLED_BY_DEFAULT}; + #endif // defined(OS_POSIX) + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + const base::Feature kDiscardableMemoryBackingTrial{ + "DiscardableMemoryBackingTrial", base::FEATURE_DISABLED_BY_DEFAULT}; + +@@ -41,13 +41,13 @@ const base::FeatureParam + DiscardableMemoryTrialGroup::kEmulatedSharedMemory, + &kDiscardableMemoryBackingParamOptions}; + +-#endif // defined(OS_ANDROID) || defined(OS_LINUX) ++#endif // defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + } // namespace features + + namespace { + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + DiscardableMemoryBacking GetBackingForFieldTrial() { + DiscardableMemoryTrialGroup trial_group = +@@ -61,11 +61,11 @@ DiscardableMemoryBacking GetBackingForFieldTrial() { + } + NOTREACHED(); + } +-#endif // defined(OS_ANDROID) || defined(OS_LINUX) ++#endif // defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + } // namespace + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + // Probe capabilities of this device to determine whether we should participate + // in the discardable memory backing trial. +@@ -87,18 +87,18 @@ DiscardableMemoryTrialGroup GetDiscardableMemoryBackingFieldTrialGroup() { + DCHECK(DiscardableMemoryBackingFieldTrialIsEnabled()); + return features::kDiscardableMemoryBackingParam.Get(); + } +-#endif // defined(OS_ANDROID) || defined(OS_LINUX) ++#endif // defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + DiscardableMemory::DiscardableMemory() = default; + + DiscardableMemory::~DiscardableMemory() = default; + + DiscardableMemoryBacking GetDiscardableMemoryBacking() { +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + if (DiscardableMemoryBackingFieldTrialIsEnabled()) { + return GetBackingForFieldTrial(); + } +-#endif // defined(OS_ANDROID) || defined(OS_LINUX) ++#endif // defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + #if defined(OS_ANDROID) + if (ashmem_device_is_supported()) +diff --git a/src/3rdparty/chromium/base/memory/discardable_memory_internal.h b/src/3rdparty/chromium/base/memory/discardable_memory_internal.h +index 9487a8c..2b8655c 100644 +--- a/src/3rdparty/chromium/base/memory/discardable_memory_internal.h ++++ b/src/3rdparty/chromium/base/memory/discardable_memory_internal.h +@@ -10,7 +10,7 @@ + #include "base/metrics/field_trial_params.h" + #include "build/build_config.h" + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + + namespace base { + +@@ -47,6 +47,6 @@ GetDiscardableMemoryBackingFieldTrialGroup(); + + } // namespace base + +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + + #endif // BASE_MEMORY_DISCARDABLE_MEMORY_INTERNAL_H_ +diff --git a/src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc b/src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc +index 48fba74..fb1abcf 100644 +--- a/src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc ++++ b/src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc +@@ -16,6 +16,7 @@ + #include "build/build_config.h" + #include "testing/gmock/include/gmock/gmock.h" + #include "testing/gtest/include/gtest/gtest.h" ++#include "base/sys_byteorder.h" + + namespace base { + +@@ -73,8 +74,8 @@ TEST_F(SharedMemoryMappingTest, SpanWithAutoDeducedElementCount) { + + 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) { +@@ -99,13 +100,13 @@ TEST_F(SharedMemoryMappingTest, SpanWithExplicitElementCount) { + + 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]); + } + +diff --git a/src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc b/src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc +index cabc170..91bbb08 100644 +--- a/src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc ++++ b/src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc +@@ -7,6 +7,7 @@ + #include + + #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()); + } + +diff --git a/src/3rdparty/chromium/base/native_library_posix.cc b/src/3rdparty/chromium/base/native_library_posix.cc +index 7a5c6f5..0cb52e0 100644 +--- a/src/3rdparty/chromium/base/native_library_posix.cc ++++ b/src/3rdparty/chromium/base/native_library_posix.cc +@@ -29,7 +29,7 @@ NativeLibrary LoadNativeLibraryWithOptions(const FilePath& library_path, + // http://crbug.com/17943, http://crbug.com/17557, http://crbug.com/36892, + // and http://crbug.com/40794. + int flags = RTLD_LAZY; +-#if defined(OS_ANDROID) || !defined(RTLD_DEEPBIND) ++#if defined(OS_ANDROID) || !defined(RTLD_DEEPBIND) || defined(OS_HAIKU) + // Certain platforms don't define RTLD_DEEPBIND. Android dlopen() requires + // further investigation, as it might vary across versions. Crash here to + // warn developers that they're trying to rely on uncertain behavior. +diff --git a/src/3rdparty/chromium/base/native_library_unittest.cc b/src/3rdparty/chromium/base/native_library_unittest.cc +index 2bfb9ec..e4ef9b4 100644 +--- a/src/3rdparty/chromium/base/native_library_unittest.cc ++++ b/src/3rdparty/chromium/base/native_library_unittest.cc +@@ -120,7 +120,7 @@ TEST(NativeLibraryTest, LoadLibrary) { + // Android dlopen() requires further investigation, as it might vary across + // versions with respect to symbol resolution scope. + // TSan and MSan error out on RTLD_DEEPBIND, https://crbug.com/705255 +-#if !defined(OS_ANDROID) && !defined(THREAD_SANITIZER) && \ ++#if !defined(OS_ANDROID) && !defined(OS_HAIKU) && !defined(THREAD_SANITIZER) && \ + !defined(MEMORY_SANITIZER) + + // Verifies that the |prefer_own_symbols| option satisfies its guarantee that +diff --git a/src/3rdparty/chromium/base/numerics/safe_math_shared_impl.h b/src/3rdparty/chromium/base/numerics/safe_math_shared_impl.h +index 3556b1e..db05fb8 100644 +--- a/src/3rdparty/chromium/base/numerics/safe_math_shared_impl.h ++++ b/src/3rdparty/chromium/base/numerics/safe_math_shared_impl.h +@@ -23,8 +23,7 @@ + // Where available use builtin math overflow support on Clang and GCC. + #elif !defined(__native_client__) && \ + ((defined(__clang__) && \ +- ((__clang_major__ > 3) || \ +- (__clang_major__ == 3 && __clang_minor__ >= 4))) || \ ++ (__clang_major__ > 6)) || \ + (defined(__GNUC__) && __GNUC__ >= 5)) + #include "base/numerics/safe_math_clang_gcc_impl.h" + #define BASE_HAS_OPTIMIZED_SAFE_MATH (1) +diff --git a/src/3rdparty/chromium/base/pickle.cc b/src/3rdparty/chromium/base/pickle.cc +index c8d784a..42bccca 100644 +--- a/src/3rdparty/chromium/base/pickle.cc ++++ b/src/3rdparty/chromium/base/pickle.cc +@@ -82,7 +82,12 @@ inline const char* PickleIterator::GetReadPointerAndAdvance( + } + + bool PickleIterator::ReadBool(bool* result) { +- return ReadBuiltinType(result); ++ int int_result; ++ if (ReadBuiltinType(&int_result)) { ++ *result = static_cast(int_result); ++ return true; ++ } else ++ return false; + } + + bool PickleIterator::ReadInt(int* result) { +diff --git a/src/3rdparty/chromium/base/posix/unix_domain_socket_unittest.cc b/src/3rdparty/chromium/base/posix/unix_domain_socket_unittest.cc +index 453064f..e30106b 100644 +--- a/src/3rdparty/chromium/base/posix/unix_domain_socket_unittest.cc ++++ b/src/3rdparty/chromium/base/posix/unix_domain_socket_unittest.cc +@@ -8,6 +8,9 @@ + #include + #include + #include ++#if defined(OS_HAIKU) ++#include ++#endif + #include + + #include "base/bind.h" +diff --git a/src/3rdparty/chromium/base/process/internal_linux.cc b/src/3rdparty/chromium/base/process/internal_linux.cc +index 35b4917..40a4f37 100644 +--- a/src/3rdparty/chromium/base/process/internal_linux.cc ++++ b/src/3rdparty/chromium/base/process/internal_linux.cc +@@ -29,7 +29,11 @@ namespace internal { + + const char kProcDir[] = "/proc"; + ++#if defined(OS_HAIKU) ++const char kStatFile[] = "status"; ++#else + const char kStatFile[] = "stat"; ++#endif + + FilePath GetProcPidDir(pid_t pid) { + return FilePath(kProcDir).Append(NumberToString(pid)); +@@ -64,6 +68,7 @@ bool ReadProcFile(const FilePath& file, std::string* buffer) { + DLOG(WARNING) << "Failed to read " << file.MaybeAsASCII(); + return false; + } ++ + return !buffer->empty(); + } + +@@ -79,6 +84,22 @@ bool ParseProcStats(const std::string& stats_data, + if (stats_data.empty()) + return false; + ++#if defined(OS_HAIKU) ++ proc_stats->clear(); ++ ++ std::vector other_stats = SplitString( ++ stats_data, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); ++ ++ for (const auto& i : other_stats) { ++ auto pos = i.find(','); ++ ++ if (pos == std::string::npos) { ++ proc_stats->push_back(i); ++ } else { ++ proc_stats->push_back(i.substr(0, pos)); ++ } ++ } ++#else + // The stat file is formatted as: + // pid (process name) data1 data2 .... dataN + // Look for the closing paren by scanning backwards, to avoid being fooled by +@@ -108,6 +129,7 @@ bool ParseProcStats(const std::string& stats_data, + base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL); + for (const auto& i : other_stats) + proc_stats->push_back(i); ++#endif + return true; + } + +@@ -155,7 +177,11 @@ int64_t ReadProcStatsAndGetFieldAsInt64(pid_t pid, ProcStatsFields field_num) { + } + + int64_t ReadProcSelfStatsAndGetFieldAsInt64(ProcStatsFields field_num) { ++#if defined(OS_HAIKU) ++ FilePath stat_file = FilePath(kProcDir).Append("curproc").Append(kStatFile); ++#else + FilePath stat_file = FilePath(kProcDir).Append("self").Append(kStatFile); ++#endif + return ReadStatFileAndGetFieldAsInt64(stat_file, field_num); + } + +@@ -171,6 +197,9 @@ size_t ReadProcStatsAndGetFieldAsSizeT(pid_t pid, + } + + Time GetBootTime() { ++#if defined(OS_HAIKU) ++ return Time(); ++#else + FilePath path("/proc/stat"); + std::string contents; + if (!ReadProcFile(path, &contents)) +@@ -184,9 +213,13 @@ Time GetBootTime() { + if (!StringToInt(btime_it->second, &btime)) + return Time(); + return Time::FromTimeT(btime); ++#endif + } + + TimeDelta GetUserCpuTimeSinceBoot() { ++#if defined(OS_HAIKU) ++ return TimeDelta(); ++#else + FilePath path("/proc/stat"); + std::string contents; + if (!ReadProcFile(path, &contents)) +@@ -210,6 +243,7 @@ TimeDelta GetUserCpuTimeSinceBoot() { + return TimeDelta(); + + return ClockTicksToTimeDelta(user + nice); ++#endif + } + + TimeDelta ClockTicksToTimeDelta(int clock_ticks) { +diff --git a/src/3rdparty/chromium/base/process/internal_linux.h b/src/3rdparty/chromium/base/process/internal_linux.h +index d8904fd..2b42351 100644 +--- a/src/3rdparty/chromium/base/process/internal_linux.h ++++ b/src/3rdparty/chromium/base/process/internal_linux.h +@@ -14,6 +14,8 @@ + + #include "base/files/file_path.h" + ++#include /* pid_t */ ++ + namespace base { + + class Time; +@@ -50,6 +52,14 @@ bool ParseProcStats(const std::string& stats_data, + // If the ordering ever changes, carefully review functions that use these + // values. + enum ProcStatsFields { ++#if defined(OS_HAIKU) ++ VM_COMM = 0, // Command name. ++ VM_PPID = 2, // Parent process id. ++ VM_PGRP = 3, // Process group id. ++ VM_STARTTIME = 7, // The process start time. ++ VM_UTIME = 8, // The user time. ++ VM_STIME = 9, // The system time ++#else + VM_COMM = 1, // Filename of executable, without parentheses. + VM_STATE = 2, // Letter indicating the state of the process. + VM_PPID = 3, // PID of the parent. +@@ -62,6 +72,7 @@ enum ProcStatsFields { + VM_STARTTIME = 21, // The time the process started in clock ticks. + VM_VSIZE = 22, // Virtual memory size in bytes. + VM_RSS = 23, // Resident Set Size in pages. ++#endif + }; + + // Reads the |field_num|th field from |proc_stats|. Returns 0 on failure. +diff --git a/src/3rdparty/chromium/base/process/kill.h b/src/3rdparty/chromium/base/process/kill.h +index 70a04d9..c0d98b8 100644 +--- a/src/3rdparty/chromium/base/process/kill.h ++++ b/src/3rdparty/chromium/base/process/kill.h +@@ -118,7 +118,7 @@ BASE_EXPORT TerminationStatus GetTerminationStatus(ProcessHandle handle, + BASE_EXPORT TerminationStatus GetKnownDeadTerminationStatus( + ProcessHandle handle, int* exit_code); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Spawns a thread to wait asynchronously for the child |process| to exit + // and then reaps it. + BASE_EXPORT void EnsureProcessGetsReaped(Process process); +diff --git a/src/3rdparty/chromium/base/process/kill_posix.cc b/src/3rdparty/chromium/base/process/kill_posix.cc +index af1f16f..43aabea 100644 +--- a/src/3rdparty/chromium/base/process/kill_posix.cc ++++ b/src/3rdparty/chromium/base/process/kill_posix.cc +@@ -168,7 +168,7 @@ void EnsureProcessTerminated(Process process) { + 0, new BackgroundReaper(std::move(process), TimeDelta::FromSeconds(2))); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + void EnsureProcessGetsReaped(Process process) { + DCHECK(!process.is_current()); + +diff --git a/src/3rdparty/chromium/base/process/launch.cc b/src/3rdparty/chromium/base/process/launch.cc +index c03e1a7..ac21346 100644 +--- a/src/3rdparty/chromium/base/process/launch.cc ++++ b/src/3rdparty/chromium/base/process/launch.cc +@@ -15,7 +15,7 @@ LaunchOptions::~LaunchOptions() = default; + + LaunchOptions LaunchOptionsForTest() { + LaunchOptions options; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // To prevent accidental privilege sharing to an untrusted child, processes + // are started with PR_SET_NO_NEW_PRIVS. Do not set that here, since this + // new child will be used for testing only. +diff --git a/src/3rdparty/chromium/base/process/launch.h b/src/3rdparty/chromium/base/process/launch.h +index 37031a8..b477053 100644 +--- a/src/3rdparty/chromium/base/process/launch.h ++++ b/src/3rdparty/chromium/base/process/launch.h +@@ -180,7 +180,7 @@ struct BASE_EXPORT LaunchOptions { + bool clear_environment = false; + #endif // OS_WIN || OS_POSIX || OS_FUCHSIA + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // If non-zero, start the process using clone(), using flags as provided. + // Unlike in clone, clone_flags may not contain a custom termination signal + // that is sent to the parent when the child dies. The termination signal will +@@ -193,7 +193,7 @@ struct BASE_EXPORT LaunchOptions { + + // Sets parent process death signal to SIGKILL. + bool kill_on_parent_death = false; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + #if defined(OS_MACOSX) && !defined(OS_IOS) + // Mach ports that will be accessible to the child process. These are not +diff --git a/src/3rdparty/chromium/base/process/memory.h b/src/3rdparty/chromium/base/process/memory.h +index 1e3ebf7..34c81e9 100644 +--- a/src/3rdparty/chromium/base/process/memory.h ++++ b/src/3rdparty/chromium/base/process/memory.h +@@ -24,7 +24,7 @@ BASE_EXPORT void EnableTerminationOnOutOfMemory(); + // Crash reporting classifies such crashes as OOM. + BASE_EXPORT void TerminateBecauseOutOfMemory(size_t size); + +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX) || defined(OS_HAIKU) + BASE_EXPORT extern size_t g_oom_size; + + // The maximum allowed value for the OOM score. +diff --git a/src/3rdparty/chromium/base/process/memory_unittest.cc b/src/3rdparty/chromium/base/process/memory_unittest.cc +index abce67e..e35154b 100644 +--- a/src/3rdparty/chromium/base/process/memory_unittest.cc ++++ b/src/3rdparty/chromium/base/process/memory_unittest.cc +@@ -106,7 +106,7 @@ TEST(MemoryTest, AllocatorShimWorking) { + // OpenBSD does not support these tests. Don't test these on ASan/TSan/MSan + // configurations: only test the real allocator. + // Windows only supports these tests with the allocator shim in place. +-#if !defined(OS_OPENBSD) && BUILDFLAG(USE_ALLOCATOR_SHIM) && \ ++#if !defined(OS_HAIKU) && BUILDFLAG(USE_ALLOCATOR_SHIM) && \ + !defined(MEMORY_TOOL_REPLACES_ALLOCATOR) + + namespace { +@@ -589,5 +589,5 @@ TEST_F(OutOfMemoryHandledTest, UncheckedCalloc) { + EXPECT_FALSE(base::UncheckedCalloc(1, test_size_, &value_)); + EXPECT_TRUE(value_ == nullptr); + } +-#endif // !defined(OS_OPENBSD) && BUILDFLAG(ENABLE_WIN_ALLOCATOR_SHIM_TESTS) && ++#endif // !defined(OS_HAIKU) && BUILDFLAG(ENABLE_WIN_ALLOCATOR_SHIM_TESTS) && + // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR) +diff --git a/src/3rdparty/chromium/base/process/process_handle.cc b/src/3rdparty/chromium/base/process/process_handle.cc +index 57635ff..a63c972 100644 +--- a/src/3rdparty/chromium/base/process/process_handle.cc ++++ b/src/3rdparty/chromium/base/process/process_handle.cc +@@ -28,7 +28,7 @@ UniqueProcId GetUniqueIdForProcess() { + : UniqueProcId(GetCurrentProcId()); + } + +-#if defined(OS_LINUX) || defined(OS_AIX) ++#if defined(OS_LINUX) || defined(OS_AIX) || defined(OS_HAIKU) + + void InitUniqueIdForProcessInPidNamespace(ProcessId pid_outside_of_namespace) { + DCHECK(pid_outside_of_namespace != kNullProcessId); +diff --git a/src/3rdparty/chromium/base/process/process_handle.h b/src/3rdparty/chromium/base/process/process_handle.h +index 94f7006..9db5a3b 100644 +--- a/src/3rdparty/chromium/base/process/process_handle.h ++++ b/src/3rdparty/chromium/base/process/process_handle.h +@@ -103,7 +103,7 @@ BASE_EXPORT ProcessId GetCurrentProcId(); + // processes may be reused. + BASE_EXPORT UniqueProcId GetUniqueIdForProcess(); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // When a process is started in a different PID namespace from the browser + // process, this function must be called with the process's PID in the browser's + // PID namespace in order to initialize its unique ID. Not thread safe. +diff --git a/src/3rdparty/chromium/base/process/process_linux.cc b/src/3rdparty/chromium/base/process/process_linux.cc +index d97226a..bd02271 100644 +--- a/src/3rdparty/chromium/base/process/process_linux.cc ++++ b/src/3rdparty/chromium/base/process/process_linux.cc +@@ -79,6 +79,9 @@ Time Process::CreationTime() const { + internal::VM_STARTTIME) + : internal::ReadProcStatsAndGetFieldAsInt64( + Pid(), internal::VM_STARTTIME); ++#if defined(OS_HAIKU) ++ return Time::FromTimeT(start_ticks); ++#else + if (!start_ticks) + return Time(); + TimeDelta start_offset = internal::ClockTicksToTimeDelta(start_ticks); +@@ -86,8 +89,10 @@ Time Process::CreationTime() const { + if (boot_time.is_null()) + return Time(); + return Time(boot_time + start_offset); ++#endif + } + ++#if defined(OS_HAIKU) + // static + bool Process::CanBackgroundProcesses() { + #if defined(OS_CHROMEOS) +@@ -139,6 +144,7 @@ bool Process::SetProcessBackgrounded(bool background) { + DPCHECK(result == 0); + return result == 0; + } ++#endif // defined(OS_HAIKU) + + #if defined(OS_CHROMEOS) + bool IsProcessBackgroundedCGroup(const StringPiece& cgroup_contents) { +diff --git a/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.cc b/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.cc +index 339e67a..833729b 100644 +--- a/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.cc ++++ b/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.cc +@@ -7,7 +7,7 @@ + namespace base { + + SamplingProfilerThreadToken GetSamplingProfilerCurrentThreadToken() { +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + return {PlatformThread::CurrentId(), pthread_self()}; + #else + return {PlatformThread::CurrentId()}; +diff --git a/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.h b/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.h +index 2e17269..d78836e 100644 +--- a/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.h ++++ b/src/3rdparty/chromium/base/profiler/sampling_profiler_thread_token.h +@@ -9,7 +9,7 @@ + #include "base/threading/platform_thread.h" + #include "build/build_config.h" + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + #include + #endif + +@@ -21,7 +21,7 @@ namespace base { + // functions used to obtain the stack base address. + struct SamplingProfilerThreadToken { + PlatformThreadId id; +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + pthread_t pthread_id; + #endif + }; +diff --git a/src/3rdparty/chromium/base/profiler/stack_copier_signal.cc b/src/3rdparty/chromium/base/profiler/stack_copier_signal.cc +index 1b60170..5995449 100644 +--- a/src/3rdparty/chromium/base/profiler/stack_copier_signal.cc ++++ b/src/3rdparty/chromium/base/profiler/stack_copier_signal.cc +@@ -4,7 +4,14 @@ + + #include "base/profiler/stack_copier_signal.h" + ++#if defined(OS_LINUX) + #include ++#include ++#elif defined(OS_FREEBSD) ++#include ++#include ++#include ++#endif + #include + #include + #include +@@ -33,8 +40,13 @@ class AsyncSafeWaitableEvent { + // for a pthread mutex. So, also check the condition. + while (true) { + int res = ++#if defined(OS_LINUX) + syscall(SYS_futex, futex_int_ptr(), FUTEX_WAIT | FUTEX_PRIVATE_FLAG, + 0, nullptr, nullptr, 0); ++#elif defined(OS_FREEBSD) ++ _umtx_op(futex_int_ptr(), UMTX_OP_WAIT_UINT_PRIVATE, 0, nullptr, ++ nullptr); ++#endif + if (futex_.load(std::memory_order_acquire) != 0) + return true; + if (res != 0) +@@ -44,8 +56,12 @@ class AsyncSafeWaitableEvent { + + void Signal() { + futex_.store(1, std::memory_order_release); ++#if defined(OS_LINUX) + syscall(SYS_futex, futex_int_ptr(), FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1, + nullptr, nullptr, 0); ++#elif defined(OS_FREEBSD) ++ _umtx_op(futex_int_ptr(), UMTX_OP_WAKE_PRIVATE, 1, nullptr, nullptr); ++#endif + } + + private: +@@ -215,11 +231,18 @@ bool StackCopierSignal::CopyStack(StackBuffer* stack_buffer, + if (!scoped_sigaction.succeeded()) + return false; + ++#if defined(OS_LINUX) + if (syscall(SYS_tgkill, getpid(), thread_delegate_->GetThreadId(), + SIGURG) != 0) { + NOTREACHED(); + return false; + } ++#elif defined(OS_FREEBSD) ++ if (thr_kill2(getpid(), thread_delegate_->GetThreadId(), SIGURG) != 0) { ++ NOTREACHED(); ++ return false; ++ } ++#endif + bool finished_waiting = wait_event.Wait(); + TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("cpu_profiler.debug"), + "StackCopierSignal copy stack"); +diff --git a/src/3rdparty/chromium/base/profiler/stack_sampling_profiler_unittest.cc b/src/3rdparty/chromium/base/profiler/stack_sampling_profiler_unittest.cc +index 0718747..11e157f 100644 +--- a/src/3rdparty/chromium/base/profiler/stack_sampling_profiler_unittest.cc ++++ b/src/3rdparty/chromium/base/profiler/stack_sampling_profiler_unittest.cc +@@ -43,7 +43,7 @@ + #include + #include + #include +-#else ++#elif !defined(OS_HAIKU) + #include + #endif + +diff --git a/src/3rdparty/chromium/base/profiler/thread_delegate_posix.cc b/src/3rdparty/chromium/base/profiler/thread_delegate_posix.cc +index 7c5d270..94f7180 100644 +--- a/src/3rdparty/chromium/base/profiler/thread_delegate_posix.cc ++++ b/src/3rdparty/chromium/base/profiler/thread_delegate_posix.cc +@@ -9,6 +9,9 @@ + #include "base/stl_util.h" + + #include "build/build_config.h" ++#if defined(OS_FREEBSD) ++#include ++#endif + + namespace base { + +@@ -17,7 +20,12 @@ namespace { + uintptr_t GetThreadStackBaseAddressImpl( + SamplingProfilerThreadToken thread_token) { + pthread_attr_t attr; ++#if defined(OS_FREEBSD) ++ pthread_attr_init(&attr); ++ pthread_attr_get_np(thread_token.pthread_id, &attr); ++#elif defined(OS_LINUX) + pthread_getattr_np(thread_token.pthread_id, &attr); ++#endif + // See crbug.com/617730 for limitations of this approach on Linux. + void* address; + size_t size; +@@ -93,16 +101,33 @@ std::vector ThreadDelegatePosix::GetRegistersToRewrite( + return { + // Return the set of callee-save registers per the i386 System V ABI + // section 2.2.3, plus the stack pointer. ++#if defined(OS_FREEBSD) ++ reinterpret_cast(&thread_context->mc_ebx), ++ reinterpret_cast(&thread_context->mc_ebp), ++ reinterpret_cast(&thread_context->mc_esi), ++ reinterpret_cast(&thread_context->mc_edi), ++ reinterpret_cast(&thread_context->mc_esp), ++#else + reinterpret_cast(&thread_context->gregs[REG_EBX]), + reinterpret_cast(&thread_context->gregs[REG_EBP]), + reinterpret_cast(&thread_context->gregs[REG_ESI]), + reinterpret_cast(&thread_context->gregs[REG_EDI]), + reinterpret_cast(&thread_context->gregs[REG_ESP]), ++#endif + }; + #elif defined(ARCH_CPU_X86_FAMILY) && defined(ARCH_CPU_64_BITS) + return { + // Return the set of callee-save registers per the x86-64 System V ABI + // section 3.2.1, plus the stack pointer. ++#if defined(OS_FREEBSD) ++ reinterpret_cast(&thread_context->mc_rbp), ++ reinterpret_cast(&thread_context->mc_rbx), ++ reinterpret_cast(&thread_context->mc_r12), ++ reinterpret_cast(&thread_context->mc_r13), ++ reinterpret_cast(&thread_context->mc_r14), ++ reinterpret_cast(&thread_context->mc_r15), ++ reinterpret_cast(&thread_context->mc_rsp), ++#else + reinterpret_cast(&thread_context->gregs[REG_RBP]), + reinterpret_cast(&thread_context->gregs[REG_RBX]), + reinterpret_cast(&thread_context->gregs[REG_R12]), +@@ -110,6 +135,7 @@ std::vector ThreadDelegatePosix::GetRegistersToRewrite( + reinterpret_cast(&thread_context->gregs[REG_R14]), + reinterpret_cast(&thread_context->gregs[REG_R15]), + reinterpret_cast(&thread_context->gregs[REG_RSP]), ++#endif + }; + #else // #if defined(ARCH_CPU_ARM_FAMILY) && defined(ARCH_CPU_32_BITS) + // Unimplemented for other architectures. +diff --git a/src/3rdparty/chromium/base/security_unittest.cc b/src/3rdparty/chromium/base/security_unittest.cc +index 5f90959..30f4019 100644 +--- a/src/3rdparty/chromium/base/security_unittest.cc ++++ b/src/3rdparty/chromium/base/security_unittest.cc +@@ -60,7 +60,7 @@ NOINLINE Type HideValueFromCompiler(volatile Type value) { + // FAILS_ is too clunky. + void OverflowTestsSoftExpectTrue(bool overflow_detected) { + if (!overflow_detected) { +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_MACOSX) ++#if defined(OS_POSIX) && !defined(OS_NACL) + // Sadly, on Linux, Android, and OSX we don't have a good story yet. Don't + // fail the test, but report. + printf("Platform has overflow: %s\n", +diff --git a/src/3rdparty/chromium/base/strings/safe_sprintf_unittest.cc b/src/3rdparty/chromium/base/strings/safe_sprintf_unittest.cc +index bb9908f..1189cf5 100644 +--- a/src/3rdparty/chromium/base/strings/safe_sprintf_unittest.cc ++++ b/src/3rdparty/chromium/base/strings/safe_sprintf_unittest.cc +@@ -730,6 +730,7 @@ TEST(SafeSPrintfTest, EmbeddedNul) { + } + + TEST(SafeSPrintfTest, EmitNULL) { ++/* Avoid compiler error: http://pastebin.com/1edWUE84 + char buf[40]; + #if defined(__GNUC__) + #pragma GCC diagnostic push +@@ -741,6 +742,7 @@ TEST(SafeSPrintfTest, EmitNULL) { + EXPECT_EQ("0x0", std::string(buf)); + EXPECT_EQ(6, SafeSPrintf(buf, "%s", NULL)); + EXPECT_EQ("", std::string(buf)); ++*/ + #if defined(__GCC__) + #pragma GCC diagnostic pop + #endif +diff --git a/src/3rdparty/chromium/base/syslog_logging.cc b/src/3rdparty/chromium/base/syslog_logging.cc +index 6b7280d..5b2b57d 100644 +--- a/src/3rdparty/chromium/base/syslog_logging.cc ++++ b/src/3rdparty/chromium/base/syslog_logging.cc +@@ -14,7 +14,7 @@ + #include "base/debug/stack_trace.h" + #include "base/strings/string_util.h" + #include "base/win/win_util.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + // defines LOG_INFO, LOG_WARNING macros that could conflict with + // base::LOG_INFO, base::LOG_WARNING. + #include +@@ -113,7 +113,7 @@ EventLogMessage::~EventLogMessage() { + + if (user_sid != nullptr) + ::LocalFree(user_sid); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + const char kEventSource[] = "chrome"; + openlog(kEventSource, LOG_NOWAIT | LOG_PID, LOG_USER); + // We can't use the defined names for the logging severity from syslog.h +diff --git a/src/3rdparty/chromium/base/system/sys_info.cc b/src/3rdparty/chromium/base/system/sys_info.cc +index 6909668..2881579 100644 +--- a/src/3rdparty/chromium/base/system/sys_info.cc ++++ b/src/3rdparty/chromium/base/system/sys_info.cc +@@ -102,7 +102,7 @@ void SysInfo::GetHardwareInfo(base::OnceCallback callback) { + #elif defined(OS_ANDROID) || defined(OS_MACOSX) + base::ThreadPool::PostTaskAndReplyWithResult( + FROM_HERE, {}, base::BindOnce(&GetHardwareInfoSync), std::move(callback)); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + base::ThreadPool::PostTaskAndReplyWithResult( + FROM_HERE, {base::MayBlock()}, base::BindOnce(&GetHardwareInfoSync), + std::move(callback)); +diff --git a/src/3rdparty/chromium/base/system/sys_info.h b/src/3rdparty/chromium/base/system/sys_info.h +index 057b0dc..280d1e3 100644 +--- a/src/3rdparty/chromium/base/system/sys_info.h ++++ b/src/3rdparty/chromium/base/system/sys_info.h +@@ -197,6 +197,8 @@ class BASE_EXPORT SysInfo { + // On Desktop this returns true when memory <= 512MB. + static bool IsLowEndDevice(); + ++ static uint64_t MaxSharedMemorySize(); ++ + private: + FRIEND_TEST_ALL_PREFIXES(SysInfoTest, AmountOfAvailablePhysicalMemory); + FRIEND_TEST_ALL_PREFIXES(debug::SystemMetricsTest, ParseMeminfo); +@@ -206,7 +208,7 @@ class BASE_EXPORT SysInfo { + static bool IsLowEndDeviceImpl(); + static HardwareInfo GetHardwareInfoSync(); + +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_AIX) || defined(OS_HAIKU) + static int64_t AmountOfAvailablePhysicalMemory( + const SystemMemoryInfoKB& meminfo); + #endif +diff --git a/src/3rdparty/chromium/base/system/sys_info_posix.cc b/src/3rdparty/chromium/base/system/sys_info_posix.cc +index 58c0c4f..5ae22a3 100644 +--- a/src/3rdparty/chromium/base/system/sys_info_posix.cc ++++ b/src/3rdparty/chromium/base/system/sys_info_posix.cc +@@ -220,6 +220,8 @@ std::string SysInfo::OperatingSystemArchitecture() { + arch = "x86"; + } else if (arch == "amd64") { + arch = "x86_64"; ++ } else if (arch == "arm64") { ++ arch = "aarch64"; + } else if (std::string(info.sysname) == "AIX") { + arch = "ppc64"; + } +diff --git a/src/3rdparty/chromium/base/threading/thread_local_storage_unittest.cc b/src/3rdparty/chromium/base/threading/thread_local_storage_unittest.cc +index 681163c..cc41d73 100644 +--- a/src/3rdparty/chromium/base/threading/thread_local_storage_unittest.cc ++++ b/src/3rdparty/chromium/base/threading/thread_local_storage_unittest.cc +@@ -86,7 +86,7 @@ class ThreadLocalStorageRunner : public DelegateSimpleThread::Delegate { + void ThreadLocalStorageCleanup(void *value) { + int *ptr = reinterpret_cast(value); + // Destructors should never be called with a NULL. +- ASSERT_NE(reinterpret_cast(NULL), ptr); ++ ASSERT_NE(static_cast(NULL), ptr); + if (*ptr == kFinalTlsValue) + return; // We've been called enough times. + ASSERT_LT(kFinalTlsValue, *ptr); +diff --git a/src/3rdparty/chromium/base/threading/thread_task_runner_handle.cc b/src/3rdparty/chromium/base/threading/thread_task_runner_handle.cc +index 4a9ac88..5f6ca41 100644 +--- a/src/3rdparty/chromium/base/threading/thread_task_runner_handle.cc ++++ b/src/3rdparty/chromium/base/threading/thread_task_runner_handle.cc +@@ -8,6 +8,7 @@ + #include + + #include "base/bind.h" ++#include "base/callback_helpers.h" + #include "base/lazy_instance.h" + #include "base/logging.h" + #include "base/run_loop.h" +@@ -38,6 +39,7 @@ bool ThreadTaskRunnerHandle::IsSet() { + return !!thread_task_runner_tls.Pointer()->Get(); + } + ++#if defined(OS_HAIKU) + // static + ScopedClosureRunner ThreadTaskRunnerHandle::OverrideForTesting( + scoped_refptr overriding_task_runner) { +@@ -82,6 +84,7 @@ ScopedClosureRunner ThreadTaskRunnerHandle::OverrideForTesting( + base::Unretained(ttrh->task_runner_.get()), + std::move(no_running_during_override))); + } ++#endif + + ThreadTaskRunnerHandle::ThreadTaskRunnerHandle( + scoped_refptr task_runner) +diff --git a/src/3rdparty/chromium/base/trace_event/process_memory_dump.h b/src/3rdparty/chromium/base/trace_event/process_memory_dump.h +index 89e6de2..f57d723 100644 +--- a/src/3rdparty/chromium/base/trace_event/process_memory_dump.h ++++ b/src/3rdparty/chromium/base/trace_event/process_memory_dump.h +@@ -22,7 +22,7 @@ + + // Define COUNT_RESIDENT_BYTES_SUPPORTED if platform supports counting of the + // resident memory. +-#if !defined(OS_NACL) ++#if !defined(OS_NACL) && !defined(OS_HAIKU) + #define COUNT_RESIDENT_BYTES_SUPPORTED + #endif + +diff --git a/src/3rdparty/chromium/build/config/compiler/compiler.gni b/src/3rdparty/chromium/build/config/compiler/compiler.gni +index 712bc99..33702a9 100644 +--- a/src/3rdparty/chromium/build/config/compiler/compiler.gni ++++ b/src/3rdparty/chromium/build/config/compiler/compiler.gni +@@ -47,7 +47,7 @@ declare_args() { + # only two architectures that are currently checked in). Turn this off when + # you are using a custom toolchain and need to control -B in cflags. + linux_use_bundled_binutils = +- linux_use_bundled_binutils_override && is_linux && ++ linux_use_bundled_binutils_override && (is_linux && !is_haiku) && + (current_cpu == "x64" || current_cpu == "x86") + binutils_path = rebase_path("//third_party/binutils/Linux_x64/Release/bin", + root_build_dir) +@@ -193,7 +193,7 @@ declare_args() { + declare_args() { + # Whether to use the gold linker from binutils instead of lld or bfd. + use_gold = +- !use_lld && !(is_chromecast && is_linux && ++ !is_haiku && !use_lld && !(is_chromecast && is_linux && + (current_cpu == "arm" || current_cpu == "mipsel")) && + ((is_linux && (current_cpu == "x64" || current_cpu == "x86" || + current_cpu == "arm" || current_cpu == "arm64" || +diff --git a/src/3rdparty/chromium/build/config/features.gni b/src/3rdparty/chromium/build/config/features.gni +index 390e9f0..724bbfd 100644 +--- a/src/3rdparty/chromium/build/config/features.gni ++++ b/src/3rdparty/chromium/build/config/features.gni +@@ -26,7 +26,7 @@ declare_args() { + proprietary_codecs = is_chrome_branded || is_chromecast + + # libudev usage. This currently only affects the content layer. +- use_udev = is_linux && !is_chromecast ++ use_udev = is_linux && !is_chromecast && !is_haiku + + use_dbus = is_linux && !is_chromecast + +diff --git a/src/3rdparty/chromium/build/config/linux/BUILD.gn b/src/3rdparty/chromium/build/config/linux/BUILD.gn +index a51ede7..7de152b 100644 +--- a/src/3rdparty/chromium/build/config/linux/BUILD.gn ++++ b/src/3rdparty/chromium/build/config/linux/BUILD.gn +@@ -30,7 +30,7 @@ config("runtime_library") { + + if ((!(is_chromeos || chromeos_is_browser_only) || + default_toolchain != "//build/toolchain/cros:target") && +- (!use_custom_libcxx || current_cpu == "mipsel") && !use_qt) { ++ (!use_custom_libcxx || current_cpu == "mipsel") && !use_qt && !is_haiku) { + libs = [ "atomic" ] + } + } +diff --git a/src/3rdparty/chromium/build/config/sysroot.gni b/src/3rdparty/chromium/build/config/sysroot.gni +index 79d27a0..6ce06dd 100644 +--- a/src/3rdparty/chromium/build/config/sysroot.gni ++++ b/src/3rdparty/chromium/build/config/sysroot.gni +@@ -24,9 +24,9 @@ declare_args() { + + # Controls default is_linux sysroot. If set to true, and sysroot + # is empty, default sysroot is calculated. +- use_sysroot = current_cpu == "x86" || current_cpu == "x64" || ++ use_sysroot = !is_haiku && (current_cpu == "x86" || current_cpu == "x64" || + current_cpu == "arm" || current_cpu == "arm64" || +- current_cpu == "mipsel" || current_cpu == "mips64el" ++ current_cpu == "mipsel" || current_cpu == "mips64el") + } + + if (sysroot == "") { +diff --git a/src/3rdparty/chromium/build/detect_host_arch.py b/src/3rdparty/chromium/build/detect_host_arch.py +index cad0f4b..29bfaed 100755 +--- a/src/3rdparty/chromium/build/detect_host_arch.py ++++ b/src/3rdparty/chromium/build/detect_host_arch.py +@@ -21,6 +21,8 @@ def HostArch(): + host_arch = 'ia32' + elif host_arch in ['x86_64', 'amd64']: + host_arch = 'x64' ++ elif host_arch.startswith('arm64'): ++ host_arch = 'arm64' + elif host_arch.startswith('arm'): + host_arch = 'arm' + elif host_arch.startswith('aarch64'): +diff --git a/src/3rdparty/chromium/build/download_nacl_toolchains.py b/src/3rdparty/chromium/build/download_nacl_toolchains.py +index 286a92a..ec36a85 100755 +--- a/src/3rdparty/chromium/build/download_nacl_toolchains.py ++++ b/src/3rdparty/chromium/build/download_nacl_toolchains.py +@@ -13,6 +13,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') +diff --git a/src/3rdparty/chromium/build/gn_run_binary.py b/src/3rdparty/chromium/build/gn_run_binary.py +index d7e2926..731b3d3 100644 +--- a/src/3rdparty/chromium/build/gn_run_binary.py ++++ b/src/3rdparty/chromium/build/gn_run_binary.py +@@ -24,7 +24,7 @@ if not os.path.isabs(path): + # The rest of the arguments are passed directly to the executable. + args = [path] + sys.argv[2:] + +-ret = subprocess.call(args) ++ret = subprocess.call(args, env={"CHROME_EXE_PATH":"${WRKSRC}/out/Release/chrome"}) + if ret != 0: + if ret <= -100: + # Windows error codes such as 0xC0000005 and 0xC0000409 are much easier to +diff --git a/src/3rdparty/chromium/build/linux/chrome.map b/src/3rdparty/chromium/build/linux/chrome.map +index 914f37b..621edc6 100644 +--- a/src/3rdparty/chromium/build/linux/chrome.map ++++ b/src/3rdparty/chromium/build/linux/chrome.map +@@ -1,4 +1,7 @@ + { ++local: ++ *; ++ + global: + __bss_start; + __data_start; +@@ -20,6 +23,10 @@ global: + # Program entry point. + _start; + ++ # FreeBSD specific variables. ++ __progname; ++ environ; ++ + # Memory allocation symbols. We want chrome and any libraries to + # share the same heap, so it is correct to export these symbols. + calloc; +@@ -81,7 +88,4 @@ global: + localtime64; + localtime64_r; + localtime_r; +- +-local: +- *; + }; +diff --git a/src/3rdparty/chromium/build/linux/unbundle/libwebp.gn b/src/3rdparty/chromium/build/linux/unbundle/libwebp.gn +index de0c230..9e96f2f 100644 +--- a/src/3rdparty/chromium/build/linux/unbundle/libwebp.gn ++++ b/src/3rdparty/chromium/build/linux/unbundle/libwebp.gn +@@ -14,14 +14,15 @@ pkg_config("system_libwebp") { + } + + shim_headers("libwebp_shim") { +- root_path = "src" ++ root_path = "src/webp" ++ prefix = "webp/" + headers = [ +- "webp/decode.h", +- "webp/demux.h", +- "webp/encode.h", +- "webp/mux.h", +- "webp/mux_types.h", +- "webp/types.h", ++ "decode.h", ++ "demux.h", ++ "encode.h", ++ "mux.h", ++ "mux_types.h", ++ "types.h", + ] + } + +diff --git a/src/3rdparty/chromium/build/linux/unbundle/replace_gn_files.py b/src/3rdparty/chromium/build/linux/unbundle/replace_gn_files.py +index d4d07f2..51cef31 100755 +--- a/src/3rdparty/chromium/build/linux/unbundle/replace_gn_files.py ++++ b/src/3rdparty/chromium/build/linux/unbundle/replace_gn_files.py +@@ -27,6 +27,7 @@ REPLACEMENTS = { + 'libevent': 'base/third_party/libevent/BUILD.gn', + 'libjpeg': 'third_party/libjpeg.gni', + 'libpng': 'third_party/libpng/BUILD.gn', ++ 'libusb': 'third_party/libusb/BUILD.gn', + 'libvpx': 'third_party/libvpx/BUILD.gn', + 'libwebp': 'third_party/libwebp/BUILD.gn', + 'libxml': 'third_party/libxml/BUILD.gn', +diff --git a/src/3rdparty/chromium/build/toolchain/linux/BUILD.gn b/src/3rdparty/chromium/build/toolchain/linux/BUILD.gn +index fa8b17e..7521041 100644 +--- a/src/3rdparty/chromium/build/toolchain/linux/BUILD.gn ++++ b/src/3rdparty/chromium/build/toolchain/linux/BUILD.gn +@@ -22,7 +22,6 @@ clang_toolchain("clang_arm") { + } + + clang_toolchain("clang_arm64") { +- toolprefix = "aarch64-linux-gnu-" + toolchain_args = { + current_cpu = "arm64" + current_os = "linux" +diff --git a/src/3rdparty/chromium/cc/BUILD.gn b/src/3rdparty/chromium/cc/BUILD.gn +index 87888ce..e3b02ea 100644 +--- a/src/3rdparty/chromium/cc/BUILD.gn ++++ b/src/3rdparty/chromium/cc/BUILD.gn +@@ -589,7 +589,7 @@ cc_test_static_library("test_support") { + if (enable_vulkan) { + deps += [ "//gpu/vulkan/init" ] + } +- if (!is_android) { ++ if (!is_android && !is_haiku) { + data_deps = [ "//third_party/mesa_headers" ] + } + } +@@ -790,7 +790,6 @@ cc_test("cc_unittests") { + ] + data_deps = [ + "//testing/buildbot/filters:cc_unittests_filters", +- "//third_party/mesa_headers", + ] + + defines = [] +diff --git a/src/3rdparty/chromium/cc/layers/scrollbar_layer_impl_base.cc b/src/3rdparty/chromium/cc/layers/scrollbar_layer_impl_base.cc +index bc9eabc..edbfbf1 100644 +--- a/src/3rdparty/chromium/cc/layers/scrollbar_layer_impl_base.cc ++++ b/src/3rdparty/chromium/cc/layers/scrollbar_layer_impl_base.cc +@@ -220,8 +220,8 @@ gfx::Rect ScrollbarLayerImplBase::ComputeThumbQuadRectWithThumbThicknessScale( + int thumb_offset = TrackStart(); + if (maximum > 0) { + float ratio = clamped_current_pos / maximum; +- float max_offset = track_length - thumb_length; +- thumb_offset += static_cast(ratio * max_offset); ++ float _max_offset = track_length - thumb_length; ++ thumb_offset += static_cast(ratio * _max_offset); + } + + float thumb_thickness_adjustment = +diff --git a/src/3rdparty/chromium/cc/trees/property_tree.cc b/src/3rdparty/chromium/cc/trees/property_tree.cc +index 63eed87..e9069e9 100644 +--- a/src/3rdparty/chromium/cc/trees/property_tree.cc ++++ b/src/3rdparty/chromium/cc/trees/property_tree.cc +@@ -1241,13 +1241,13 @@ gfx::ScrollOffset ScrollTree::MaxScrollOffset(int scroll_node_id) const { + + gfx::Size clip_layer_bounds = container_bounds(scroll_node->id); + +- gfx::ScrollOffset max_offset( ++ gfx::ScrollOffset _max_offset( + scaled_scroll_bounds.width() - clip_layer_bounds.width(), + scaled_scroll_bounds.height() - clip_layer_bounds.height()); + +- max_offset.Scale(1 / scale_factor); +- max_offset.SetToMax(gfx::ScrollOffset()); +- return max_offset; ++ _max_offset.Scale(1 / scale_factor); ++ _max_offset.SetToMax(gfx::ScrollOffset()); ++ return _max_offset; + } + + gfx::SizeF ScrollTree::scroll_bounds(int scroll_node_id) const { +diff --git a/src/3rdparty/chromium/chrome/app/chromium_strings.grd b/src/3rdparty/chromium/chrome/app/chromium_strings.grd +index 9c44b2c..c892e25 100644 +--- a/src/3rdparty/chromium/chrome/app/chromium_strings.grd ++++ b/src/3rdparty/chromium/chrome/app/chromium_strings.grd +@@ -680,7 +680,7 @@ Chromium is unable to recover your settings. + + + +- ++ + + Your system administrator has configured Chromium to open an alternative browser to access $1example.com. + +@@ -781,7 +781,7 @@ Chromium is unable to recover your settings. + + + +- ++ + + The profile appears to be in use by another Chromium process ($112345) on another computer ($2example.com). Chromium has locked the profile so that it doesn't get corrupted. If you are sure no other processes are using this profile, you can unlock the profile and relaunch Chromium. + +@@ -1003,7 +1003,7 @@ Chromium is unable to recover your settings. + + + +- ++ + + Restart Chromium to enable $1Flash + +diff --git a/src/3rdparty/chromium/chrome/app/generated_resources.grd b/src/3rdparty/chromium/chrome/app/generated_resources.grd +index 288c442..982bd68 100644 +--- a/src/3rdparty/chromium/chrome/app/generated_resources.grd ++++ b/src/3rdparty/chromium/chrome/app/generated_resources.grd +@@ -5137,7 +5137,7 @@ Keep your key file in a safe place. You will need it to create new versions of y + + + +- ++ + + Legacy Browser Support + +@@ -6880,7 +6880,7 @@ the Bookmarks menu."> + Google Pay + + +- ++ + + Use system title bar and borders + +@@ -7806,7 +7806,7 @@ Please help our engineers fix this problem. Tell us what happened right before y + Set as default + + +- ++ + + Minimize + +diff --git a/src/3rdparty/chromium/chrome/app/google_chrome_strings.grd b/src/3rdparty/chromium/chrome/app/google_chrome_strings.grd +index 3ba868c..3b67a97 100644 +--- a/src/3rdparty/chromium/chrome/app/google_chrome_strings.grd ++++ b/src/3rdparty/chromium/chrome/app/google_chrome_strings.grd +@@ -692,7 +692,7 @@ Google Chrome is unable to recover your settings. + + + +- ++ + + Your system administrator has configured Google Chrome to open an alternative browser to access $1example.com. + +@@ -793,7 +793,7 @@ Google Chrome is unable to recover your settings. + + + +- ++ + + The profile appears to be in use by another Google Chrome process ($112345) on another computer ($2example.com). Chrome has locked the profile so that it doesn't get corrupted. If you are sure no other processes are using this profile, you can unlock the profile and relaunch Chrome. + +@@ -1022,7 +1022,7 @@ Google Chrome is unable to recover your settings. + + + +- ++ + + Restart Chrome to enable $1Flash + +diff --git a/src/3rdparty/chromium/chrome/app/settings_strings.grdp b/src/3rdparty/chromium/chrome/app/settings_strings.grdp +index 943765d..77310cb 100644 +--- a/src/3rdparty/chromium/chrome/app/settings_strings.grdp ++++ b/src/3rdparty/chromium/chrome/app/settings_strings.grdp +@@ -111,7 +111,7 @@ + Themes + + +- ++ + + GTK+ + +@@ -125,7 +125,7 @@ + Use Classic + + +- ++ + + Reset to default + +diff --git a/src/3rdparty/chromium/chrome/app/theme/chrome_unscaled_resources.grd b/src/3rdparty/chromium/chrome/app/theme/chrome_unscaled_resources.grd +index 01c0b80..fba36cc 100644 +--- a/src/3rdparty/chromium/chrome/app/theme/chrome_unscaled_resources.grd ++++ b/src/3rdparty/chromium/chrome/app/theme/chrome_unscaled_resources.grd +@@ -18,7 +18,7 @@ + + + +- ++ + + + +diff --git a/src/3rdparty/chromium/chrome/browser/devtools/devtools_eye_dropper.cc b/src/3rdparty/chromium/chrome/browser/devtools/devtools_eye_dropper.cc +index a3b4d68..de81e81 100644 +--- a/src/3rdparty/chromium/chrome/browser/devtools/devtools_eye_dropper.cc ++++ b/src/3rdparty/chromium/chrome/browser/devtools/devtools_eye_dropper.cc +@@ -164,7 +164,7 @@ void DevToolsEyeDropper::UpdateCursor() { + // magnified projection only with centered hotspot. + // Mac Retina requires cursor to be > 120px in order to render smoothly. + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const float kCursorSize = 63; + const float kDiameter = 63; + const float kHotspotOffset = 32; +diff --git a/src/3rdparty/chromium/chrome/browser/extensions/BUILD.gn b/src/3rdparty/chromium/chrome/browser/extensions/BUILD.gn +index 453d9d9..432dc3f 100644 +--- a/src/3rdparty/chromium/chrome/browser/extensions/BUILD.gn ++++ b/src/3rdparty/chromium/chrome/browser/extensions/BUILD.gn +@@ -1185,6 +1185,12 @@ jumbo_static_library("extensions") { + deps += [ "//chrome/common:service_process_mojom" ] + } + ++ if (is_haiku) { ++ sources -= [ ++ "api/image_writer_private/removable_storage_provider_linux.cc", ++ ] ++ } ++ + if (enable_service_discovery) { + sources += [ + "api/mdns/mdns_api.cc", +diff --git a/src/3rdparty/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider.cc b/src/3rdparty/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider.cc +index 2b7c60d..c8bb7a7 100644 +--- a/src/3rdparty/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider.cc ++++ b/src/3rdparty/chromium/chrome/browser/extensions/api/image_writer_private/removable_storage_provider.cc +@@ -22,6 +22,7 @@ static base::LazyInstance>::DestructorAtExit + + void RemovableStorageProvider::GetAllDevices(DeviceListReadyCallback callback) { + DCHECK_CURRENTLY_ON(content::BrowserThread::UI); ++#if !defined(OS_HAIKU) + if (g_test_device_list.Get().get() != nullptr) { + base::ThreadTaskRunnerHandle::Get()->PostTask( + FROM_HERE, +@@ -35,6 +36,9 @@ void RemovableStorageProvider::GetAllDevices(DeviceListReadyCallback callback) { + base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN}, + base::BindOnce(&RemovableStorageProvider::PopulateDeviceList), + std::move(callback)); ++#else ++ NOTIMPLEMENTED(); ++#endif + } + + // static +diff --git a/src/3rdparty/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.h b/src/3rdparty/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.h +index 0c4eaac..6fec344 100644 +--- a/src/3rdparty/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.h ++++ b/src/3rdparty/chromium/chrome/browser/extensions/api/input_ime/input_ime_api.h +@@ -31,7 +31,7 @@ + + #if defined(OS_CHROMEOS) + #include "chrome/browser/extensions/api/input_ime/input_ime_api_chromeos.h" +-#elif defined(OS_LINUX) || defined(OS_WIN) ++#elif defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + #include "chrome/browser/extensions/api/input_ime/input_ime_api_nonchromeos.h" + #endif // defined(OS_CHROMEOS) + +diff --git a/src/3rdparty/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc b/src/3rdparty/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc +index dbafaf3..4668691 100644 +--- a/src/3rdparty/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc ++++ b/src/3rdparty/chromium/chrome/browser/extensions/api/runtime/chrome_runtime_api_delegate.cc +@@ -299,6 +299,8 @@ bool ChromeRuntimeAPIDelegate::GetPlatformInfo(PlatformInfo* info) { + info->os = extensions::api::runtime::PLATFORM_OS_CROS; + } else if (strcmp(os, "linux") == 0) { + info->os = extensions::api::runtime::PLATFORM_OS_LINUX; ++ } else if (strcmp(os, "haiku") == 0) { ++ info->os = extensions::api::runtime::PLATFORM_OS_HAIKU; + } else if (strcmp(os, "openbsd") == 0) { + info->os = extensions::api::runtime::PLATFORM_OS_OPENBSD; + } else { +diff --git a/src/3rdparty/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc b/src/3rdparty/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc +index 99993cc..3a5e098 100644 +--- a/src/3rdparty/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc ++++ b/src/3rdparty/chromium/chrome/browser/extensions/api/settings_private/prefs_util.cc +@@ -161,7 +161,7 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() { + (*s_whitelist)[bookmarks::prefs::kShowBookmarkBar] = + settings_api::PrefType::PREF_TYPE_BOOLEAN; + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + (*s_whitelist)[::prefs::kUseCustomChromeFrame] = + settings_api::PrefType::PREF_TYPE_BOOLEAN; + #endif +@@ -171,7 +171,7 @@ const PrefsUtil::TypedPrefMap& PrefsUtil::GetWhitelistedKeys() { + // Appearance settings. + (*s_whitelist)[::prefs::kCurrentThemeID] = + settings_api::PrefType::PREF_TYPE_STRING; +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_HAIKU) || defined(OS_LINUX)) && !defined(OS_CHROMEOS) + (*s_whitelist)[::prefs::kUsesSystemTheme] = + settings_api::PrefType::PREF_TYPE_BOOLEAN; + #endif +diff --git a/src/3rdparty/chromium/chrome/browser/ui/webui/about_ui.cc b/src/3rdparty/chromium/chrome/browser/ui/webui/about_ui.cc +index 8973b19..e1b0c19 100644 +--- a/src/3rdparty/chromium/chrome/browser/ui/webui/about_ui.cc ++++ b/src/3rdparty/chromium/chrome/browser/ui/webui/about_ui.cc +@@ -560,7 +560,7 @@ std::string ChromeURLs() { + return html; + } + +-#if defined(OS_LINUX) || defined(OS_OPENBSD) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + std::string AboutLinuxProxyConfig() { + std::string data; + AppendHeader(&data, 0, +@@ -616,7 +616,7 @@ void AboutUIHTMLSource::StartDataRequest( + response = + ui::ResourceBundle::GetSharedInstance().LoadDataResourceString(idr); + } +-#if defined(OS_LINUX) || defined(OS_OPENBSD) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + } else if (source_name_ == chrome::kChromeUILinuxProxyConfigHost) { + response = AboutLinuxProxyConfig(); + #endif +diff --git a/src/3rdparty/chromium/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc b/src/3rdparty/chromium/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc +index 72e6f86..33c60e3 100644 +--- a/src/3rdparty/chromium/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc ++++ b/src/3rdparty/chromium/chrome/browser/ui/webui/chrome_web_ui_controller_factory.cc +@@ -235,11 +235,11 @@ + #include "chrome/browser/ui/webui/conflicts/conflicts_ui.h" + #endif + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + #include "chrome/browser/ui/webui/discards/discards_ui.h" + #endif + +-#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + #include "chrome/browser/ui/webui/sandbox/sandbox_internals_ui.h" + #endif + +@@ -361,7 +361,7 @@ bool IsAboutUI(const GURL& url) { + #if !defined(OS_ANDROID) + || url.host_piece() == chrome::kChromeUITermsHost + #endif +-#if defined(OS_LINUX) || defined(OS_OPENBSD) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + || url.host_piece() == chrome::kChromeUILinuxProxyConfigHost + #endif + #if defined(OS_CHROMEOS) +@@ -705,7 +705,7 @@ WebUIFactoryFunction GetWebUIFactoryFunction(WebUI* web_ui, + if (url.host_piece() == chrome::kChromeUINaClHost) + return &NewWebUI; + #endif +-#if (defined(OS_LINUX) && defined(TOOLKIT_VIEWS)) || defined(USE_AURA) ++#if (defined(OS_LINUX) && defined(TOOLKIT_VIEWS)) || defined(USE_AURA) || defined(OS_HAIKU) + if (url.host_piece() == chrome::kChromeUITabModalConfirmDialogHost) + return &NewWebUI; + #endif +@@ -755,17 +755,17 @@ WebUIFactoryFunction GetWebUIFactoryFunction(WebUI* web_ui, + return &NewWebUI; + } + #endif +-#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + if (url.host_piece() == chrome::kChromeUISandboxHost) { + return &NewWebUI; + } + #endif +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + if (url.host_piece() == chrome::kChromeUIDiscardsHost) + return &NewWebUI; + #endif + #if defined(OS_WIN) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + if (url.host_piece() == chrome::kChromeUIBrowserSwitchHost) + return &NewWebUI; + #endif +diff --git a/src/3rdparty/chromium/chrome/common/BUILD.gn b/src/3rdparty/chromium/chrome/common/BUILD.gn +index 625031e..dc062ff 100644 +--- a/src/3rdparty/chromium/chrome/common/BUILD.gn ++++ b/src/3rdparty/chromium/chrome/common/BUILD.gn +@@ -277,6 +277,10 @@ static_library("common") { + public_deps += [ "//ppapi/shared_impl" ] + } + ++ if (is_haiku) { ++ sources -= [ "component_flash_hint_file_linux.cc" ] ++ } ++ + if (enable_extensions) { + sources += [ + "cast_messages.cc", +diff --git a/src/3rdparty/chromium/chrome/common/chrome_paths.cc b/src/3rdparty/chromium/chrome/common/chrome_paths.cc +index 1ca92ba..20fb2e9 100644 +--- a/src/3rdparty/chromium/chrome/common/chrome_paths.cc ++++ b/src/3rdparty/chromium/chrome/common/chrome_paths.cc +@@ -51,21 +51,21 @@ const base::FilePath::CharType kPepperFlashSystemBaseDirectory[] = + FILE_PATH_LITERAL("Internet Plug-Ins/PepperFlashPlayer"); + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // The path to the external extension .json files. + // /usr/share seems like a good choice, see: http://www.pathname.com/fhs/ + const base::FilePath::CharType kFilepathSinglePrefExtensions[] = + #if BUILDFLAG(GOOGLE_CHROME_BRANDING) +- FILE_PATH_LITERAL("/usr/share/google-chrome/extensions"); ++ FILE_PATH_LITERAL("%%LOCALBASE%%/share/google-chrome/extensions"); + #else +- FILE_PATH_LITERAL("/usr/share/chromium/extensions"); ++ FILE_PATH_LITERAL("%%LOCALBASE%%/share/chromium/extensions"); + #endif // BUILDFLAG(GOOGLE_CHROME_BRANDING) + + // The path to the hint file that tells the pepper plugin loader + // where it can find the latest component updated flash. + const base::FilePath::CharType kComponentUpdatedFlashHint[] = + FILE_PATH_LITERAL("latest-component-updated-flash"); +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + #if defined(OS_LINUX) && BUILDFLAG(ENABLE_WIDEVINE_CDM_COMPONENT) + // The name of the hint file that tells the latest component updated Widevine +@@ -204,7 +204,7 @@ bool PathProvider(int key, base::FilePath* result) { + return false; + break; + case chrome::DIR_DEFAULT_DOWNLOADS_SAFE: +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + if (!GetUserDownloadsDirectorySafe(&cur)) + return false; + break; +@@ -495,6 +495,9 @@ bool PathProvider(int key, base::FilePath* result) { + case chrome::DIR_POLICY_FILES: { + #if BUILDFLAG(GOOGLE_CHROME_BRANDING) + cur = base::FilePath(FILE_PATH_LITERAL("/etc/opt/chrome/policies")); ++#elif defined(OS_HAIKU) ++ cur = base::FilePath(FILE_PATH_LITERAL( ++ "%%LOCALBASE%%/etc/chrome/policies")); + #else + cur = base::FilePath(FILE_PATH_LITERAL("/etc/chromium/policies")); + #endif +@@ -502,7 +505,7 @@ bool PathProvider(int key, base::FilePath* result) { + } + #endif + #if defined(OS_CHROMEOS) || \ +- (defined(OS_LINUX) && BUILDFLAG(CHROMIUM_BRANDING)) || defined(OS_MACOSX) ++ ((defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(CHROMIUM_BRANDING)) || defined(OS_MACOSX) + case chrome::DIR_USER_EXTERNAL_EXTENSIONS: { + if (!base::PathService::Get(chrome::DIR_USER_DATA, &cur)) + return false; +@@ -510,7 +513,7 @@ bool PathProvider(int key, base::FilePath* result) { + break; + } + #endif +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + case chrome::DIR_STANDALONE_EXTERNAL_EXTENSIONS: { + cur = base::FilePath(kFilepathSinglePrefExtensions); + break; +@@ -545,7 +548,7 @@ bool PathProvider(int key, base::FilePath* result) { + #endif + break; + +-#if defined(OS_LINUX) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + case chrome::DIR_NATIVE_MESSAGING: + #if defined(OS_MACOSX) + #if BUILDFLAG(GOOGLE_CHROME_BRANDING) +@@ -559,6 +562,9 @@ bool PathProvider(int key, base::FilePath* result) { + #if BUILDFLAG(GOOGLE_CHROME_BRANDING) + cur = base::FilePath(FILE_PATH_LITERAL( + "/etc/opt/chrome/native-messaging-hosts")); ++#elif defined(OS_HAIKU) ++ cur = base::FilePath(FILE_PATH_LITERAL( ++ "%%LOCALBASE%%/etc/chrome/native-messaging-hosts")); + #else + cur = base::FilePath(FILE_PATH_LITERAL( + "/etc/chromium/native-messaging-hosts")); +@@ -571,7 +577,7 @@ bool PathProvider(int key, base::FilePath* result) { + return false; + cur = cur.Append(FILE_PATH_LITERAL("NativeMessagingHosts")); + break; +-#endif // defined(OS_LINUX) || defined(OS_MACOSX) ++#endif // defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + #if !defined(OS_ANDROID) + case chrome::DIR_GLOBAL_GCM_STORE: + if (!base::PathService::Get(chrome::DIR_USER_DATA, &cur)) +@@ -579,7 +585,7 @@ bool PathProvider(int key, base::FilePath* result) { + cur = cur.Append(kGCMStoreDirname); + break; + #endif // !defined(OS_ANDROID) +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + case chrome::FILE_COMPONENT_FLASH_HINT: + if (!base::PathService::Get( + chrome::DIR_COMPONENT_UPDATED_PEPPER_FLASH_PLUGIN, &cur)) { +@@ -587,7 +593,7 @@ bool PathProvider(int key, base::FilePath* result) { + } + cur = cur.Append(kComponentUpdatedFlashHint); + break; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + #if defined(OS_CHROMEOS) + case chrome::FILE_CHROME_OS_COMPONENT_FLASH: + cur = base::FilePath(kChromeOSComponentFlash); +diff --git a/src/3rdparty/chromium/chrome/common/chrome_paths.h b/src/3rdparty/chromium/chrome/common/chrome_paths.h +index 3f73d86..08d049f 100644 +--- a/src/3rdparty/chromium/chrome/common/chrome_paths.h ++++ b/src/3rdparty/chromium/chrome/common/chrome_paths.h +@@ -53,7 +53,7 @@ enum { + // contains subdirectories. + #endif + #if defined(OS_CHROMEOS) || \ +- (defined(OS_LINUX) && BUILDFLAG(CHROMIUM_BRANDING)) || defined(OS_MACOSX) ++ ((defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(CHROMIUM_BRANDING)) || defined(OS_MACOSX) + DIR_USER_EXTERNAL_EXTENSIONS, // Directory for per-user external extensions + // on Chrome Mac and Chromium Linux. + // On Chrome OS, this path is used for OEM +@@ -61,7 +61,7 @@ enum { + // create it. + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + DIR_STANDALONE_EXTERNAL_EXTENSIONS, // Directory for 'per-extension' + // definition manifest files that + // describe extensions which are to be +@@ -122,7 +122,7 @@ enum { + DIR_SUPERVISED_USER_INSTALLED_WHITELISTS, // Directory where sanitized + // supervised user whitelists are + // installed. +-#if defined(OS_LINUX) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + DIR_NATIVE_MESSAGING, // System directory where native messaging host + // manifest files are stored. + DIR_USER_NATIVE_MESSAGING, // Directory with Native Messaging Hosts +@@ -137,10 +137,10 @@ enum { + DIR_GEN_TEST_DATA, // Directory where generated test data resides. + DIR_TEST_DATA, // Directory where unit test data resides. + DIR_TEST_TOOLS, // Directory where unit test tools reside. +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + FILE_COMPONENT_FLASH_HINT, // A file in a known location that points to + // the component updated flash plugin. +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + #if defined(OS_CHROMEOS) + FILE_CHROME_OS_COMPONENT_FLASH, // The location of component updated Flash on + // Chrome OS. +diff --git a/src/3rdparty/chromium/chrome/common/chrome_paths_internal.h b/src/3rdparty/chromium/chrome/common/chrome_paths_internal.h +index aae5a1f..2981f05 100644 +--- a/src/3rdparty/chromium/chrome/common/chrome_paths_internal.h ++++ b/src/3rdparty/chromium/chrome/common/chrome_paths_internal.h +@@ -45,7 +45,7 @@ void GetUserCacheDirectory(const base::FilePath& profile_dir, base::FilePath* re + // Get the path to the user's documents directory. + bool GetUserDocumentsDirectory(base::FilePath* result); + +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + // Gets the path to a safe default download directory for a user. + bool GetUserDownloadsDirectorySafe(base::FilePath* result); + #endif +diff --git a/src/3rdparty/chromium/chrome/common/chrome_switches.cc b/src/3rdparty/chromium/chrome/common/chrome_switches.cc +index 411a2dd..9f071e1 100644 +--- a/src/3rdparty/chromium/chrome/common/chrome_switches.cc ++++ b/src/3rdparty/chromium/chrome/common/chrome_switches.cc +@@ -850,7 +850,7 @@ const char kAllowNaClFileHandleAPI[] = "allow-nacl-file-handle-api"; + const char kAllowNaClSocketAPI[] = "allow-nacl-socket-api"; + #endif + +-#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_WIN) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_HAIKU) + const char kEnableNewAppMenuIcon[] = "enable-new-app-menu-icon"; + + // Causes the browser to launch directly in guest mode. +diff --git a/src/3rdparty/chromium/chrome/common/chrome_switches.h b/src/3rdparty/chromium/chrome/common/chrome_switches.h +index d4e12dd..39045fa 100644 +--- a/src/3rdparty/chromium/chrome/common/chrome_switches.h ++++ b/src/3rdparty/chromium/chrome/common/chrome_switches.h +@@ -259,7 +259,7 @@ extern const char kAllowNaClFileHandleAPI[]; + extern const char kAllowNaClSocketAPI[]; + #endif + +-#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_WIN) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_HAIKU) + extern const char kEnableNewAppMenuIcon[]; + extern const char kGuest[]; + #endif +diff --git a/src/3rdparty/chromium/chrome/common/features.gni b/src/3rdparty/chromium/chrome/common/features.gni +index d3a55eb..a49e9a0 100644 +--- a/src/3rdparty/chromium/chrome/common/features.gni ++++ b/src/3rdparty/chromium/chrome/common/features.gni +@@ -55,7 +55,7 @@ declare_args() { + # Enables password change in leaked password dialog, disabled by default. + enable_password_change_in_leaked_dialog = false + +- enable_service_discovery = (enable_mdns && !is_android) || is_mac ++ enable_service_discovery = (enable_mdns && !is_android) || is_mac || is_haiku + + # Enables use of the session service, which is enabled by default. + # Android stores them separately on the Java side. +diff --git a/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.cc b/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.cc +index dd0c281..e226bc2 100644 +--- a/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.cc ++++ b/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.cc +@@ -15,7 +15,7 @@ + #include "ppapi/proxy/ppapi_messages.h" + #include "ppapi/proxy/serialized_structs.h" + +-#if defined(OS_LINUX) || defined(OS_OPENBSD) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "components/services/font/public/cpp/font_loader.h" + #include "content/public/common/common_sandbox_support_linux.h" + #elif defined(OS_WIN) +@@ -29,7 +29,7 @@ PepperFlashFontFileHost::PepperFlashFontFileHost( + const ppapi::proxy::SerializedFontDescription& description, + PP_PrivateFontCharset charset) + : ResourceHost(host->GetPpapiHost(), instance, resource) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // The global SkFontConfigInterface is configured and initialized with a + // SkFontconfigInterface compatible font_service::FontLoader in + // RendererBlinkPlatformImpl (called from RenderThreadImpl::Init) at startup +@@ -74,7 +74,7 @@ bool PepperFlashFontFileHost::GetFontData(uint32_t table, + void* buffer, + size_t* length) { + bool result = false; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (font_file_.IsValid()) { + result = content::GetFontTable(font_file_.GetPlatformFile(), table, + 0 /* offset */, +diff --git a/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.h b/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.h +index 6d63578..47350ce 100644 +--- a/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.h ++++ b/src/3rdparty/chromium/chrome/renderer/pepper/pepper_flash_font_file_host.h +@@ -14,7 +14,7 @@ + #include "ppapi/c/private/pp_private_font_charset.h" + #include "ppapi/host/resource_host.h" + +-#if defined(OS_LINUX) || defined(OS_OPENBSD) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "base/files/file.h" + #elif defined(OS_WIN) + #include "third_party/skia/include/core/SkRefCnt.h" +@@ -50,7 +50,7 @@ class PepperFlashFontFileHost : public ppapi::host::ResourceHost { + uint32_t table); + bool GetFontData(uint32_t table, void* buffer, size_t* length); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + base::File font_file_; + #elif defined(OS_WIN) + sk_sp typeface_; +diff --git a/src/3rdparty/chromium/components/autofill/content/renderer/password_form_conversion_utils.cc b/src/3rdparty/chromium/components/autofill/content/renderer/password_form_conversion_utils.cc +index 9c7360f..20fdae2 100644 +--- a/src/3rdparty/chromium/components/autofill/content/renderer/password_form_conversion_utils.cc ++++ b/src/3rdparty/chromium/components/autofill/content/renderer/password_form_conversion_utils.cc +@@ -19,7 +19,11 @@ + #include "third_party/blink/public/web/web_form_control_element.h" + #include "third_party/blink/public/web/web_input_element.h" + #include "third_party/blink/public/web/web_local_frame.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + #include "url/gurl.h" + + using blink::WebElement; +diff --git a/src/3rdparty/chromium/components/content_settings/core/browser/website_settings_registry.cc b/src/3rdparty/chromium/components/content_settings/core/browser/website_settings_registry.cc +index 1198a17..2fbb502 100644 +--- a/src/3rdparty/chromium/components/content_settings/core/browser/website_settings_registry.cc ++++ b/src/3rdparty/chromium/components/content_settings/core/browser/website_settings_registry.cc +@@ -66,7 +66,7 @@ const WebsiteSettingsInfo* WebsiteSettingsRegistry::Register( + #if defined(OS_WIN) + if (!(platform & PLATFORM_WINDOWS)) + return nullptr; +-#elif defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#elif (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + if (!(platform & PLATFORM_LINUX)) + return nullptr; + #elif defined(OS_MACOSX) && !defined(OS_IOS) +diff --git a/src/3rdparty/chromium/components/cookie_config/cookie_store_util.cc b/src/3rdparty/chromium/components/cookie_config/cookie_store_util.cc +index c1aa494..617df10 100644 +--- a/src/3rdparty/chromium/components/cookie_config/cookie_store_util.cc ++++ b/src/3rdparty/chromium/components/cookie_config/cookie_store_util.cc +@@ -11,7 +11,7 @@ + + namespace cookie_config { + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + namespace { + + // Use the operating system's mechanisms to encrypt cookies before writing +@@ -63,10 +63,10 @@ base::LazyInstance::DestructorAtExit + net::CookieCryptoDelegate* GetCookieCryptoDelegate() { + return g_cookie_crypto_delegate.Pointer(); + } +-#else // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#else // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + net::CookieCryptoDelegate* GetCookieCryptoDelegate() { + return NULL; + } +-#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + + } // namespace cookie_config +diff --git a/src/3rdparty/chromium/components/download/internal/common/base_file.cc b/src/3rdparty/chromium/components/download/internal/common/base_file.cc +index 16d1f3f..74f4732 100644 +--- a/src/3rdparty/chromium/components/download/internal/common/base_file.cc ++++ b/src/3rdparty/chromium/components/download/internal/common/base_file.cc +@@ -604,7 +604,7 @@ GURL GetEffectiveAuthorityURL(const GURL& source_url, + + } // namespace + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + + DownloadInterruptReason BaseFile::AnnotateWithSourceInformationSync( + const std::string& client_guid, +diff --git a/src/3rdparty/chromium/components/feedback/anonymizer_tool.cc b/src/3rdparty/chromium/components/feedback/anonymizer_tool.cc +index 4f535cc..3bd4934 100644 +--- a/src/3rdparty/chromium/components/feedback/anonymizer_tool.cc ++++ b/src/3rdparty/chromium/components/feedback/anonymizer_tool.cc +@@ -15,7 +15,11 @@ + #include "base/threading/thread_restrictions.h" + #include "content/public/browser/browser_thread.h" + #include "net/base/ip_address.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + using re2::RE2; + +diff --git a/src/3rdparty/chromium/components/flags_ui/flags_state.cc b/src/3rdparty/chromium/components/flags_ui/flags_state.cc +index 5156abf..88980f6 100644 +--- a/src/3rdparty/chromium/components/flags_ui/flags_state.cc ++++ b/src/3rdparty/chromium/components/flags_ui/flags_state.cc +@@ -693,7 +693,7 @@ int FlagsState::GetCurrentPlatform() { + return kOsWin; + #elif defined(OS_CHROMEOS) // Needs to be before the OS_LINUX check. + return kOsCrOS; +-#elif defined(OS_LINUX) || defined(OS_OPENBSD) ++#elif defined(OS_LINUX) || defined(OS_OPENBSD) || defined(OS_FREEBSD) + return kOsLinux; + #elif defined(OS_ANDROID) + return kOsAndroid; +diff --git a/src/3rdparty/chromium/components/keyed_service/core/dependency_graph_unittest.cc b/src/3rdparty/chromium/components/keyed_service/core/dependency_graph_unittest.cc +index 4fb91ff..f117691 100644 +--- a/src/3rdparty/chromium/components/keyed_service/core/dependency_graph_unittest.cc ++++ b/src/3rdparty/chromium/components/keyed_service/core/dependency_graph_unittest.cc +@@ -9,7 +9,11 @@ + #include "components/keyed_service/core/dependency_graph.h" + #include "components/keyed_service/core/dependency_node.h" + #include "testing/gtest/include/gtest/gtest.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + namespace { + +diff --git a/src/3rdparty/chromium/components/metrics/drive_metrics_provider_linux.cc b/src/3rdparty/chromium/components/metrics/drive_metrics_provider_linux.cc +index 149405e..2dd823b 100644 +--- a/src/3rdparty/chromium/components/metrics/drive_metrics_provider_linux.cc ++++ b/src/3rdparty/chromium/components/metrics/drive_metrics_provider_linux.cc +@@ -4,7 +4,13 @@ + + #include "components/metrics/drive_metrics_provider.h" + ++#if defined(OS_HAIKU) ++#include ++#define MAJOR(dev) major(dev) ++#define MINOR(dev) minor(dev) ++#else + #include // For MAJOR()/MINOR(). ++#endif + #include + #include + +diff --git a/src/3rdparty/chromium/components/metrics/metrics_log.cc b/src/3rdparty/chromium/components/metrics/metrics_log.cc +index ab4e04f..4bd556d 100644 +--- a/src/3rdparty/chromium/components/metrics/metrics_log.cc ++++ b/src/3rdparty/chromium/components/metrics/metrics_log.cc +@@ -210,7 +210,7 @@ void MetricsLog::RecordCoreSystemProfile( + // OperatingSystemVersion refers to the ChromeOS release version. + #if defined(OS_CHROMEOS) + os->set_kernel_version(base::SysInfo::KernelVersion()); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + // Linux operating system version is copied over into kernel version to be + // consistent. + os->set_kernel_version(base::SysInfo::OperatingSystemVersion()); +diff --git a/src/3rdparty/chromium/components/metrics/system_memory_stats_recorder_linux.cc b/src/3rdparty/chromium/components/metrics/system_memory_stats_recorder_linux.cc +index 72c6084..be00f22 100644 +--- a/src/3rdparty/chromium/components/metrics/system_memory_stats_recorder_linux.cc ++++ b/src/3rdparty/chromium/components/metrics/system_memory_stats_recorder_linux.cc +@@ -30,6 +30,7 @@ namespace metrics { + UMA_HISTOGRAM_LINEAR(name, sample, 2500, 50) + + void RecordMemoryStats(RecordMemoryStatsType type) { ++#if !defined(OS_FREEBSD) + base::SystemMemoryInfoKB memory; + if (!base::GetSystemMemoryInfo(&memory)) + return; +@@ -81,6 +82,7 @@ void RecordMemoryStats(RecordMemoryStatsType type) { + break; + } + } ++#endif // !defined(OS_FREEBSD) + } + + } // namespace metrics +diff --git a/src/3rdparty/chromium/components/neterror/resources/neterror.js b/src/3rdparty/chromium/components/neterror/resources/neterror.js +index fb7fd6d..20f6a09 100644 +--- a/src/3rdparty/chromium/components/neterror/resources/neterror.js ++++ b/src/3rdparty/chromium/components/neterror/resources/neterror.js +@@ -201,7 +201,7 @@ function setUpCachedButton(buttonStrings) { + } + + let primaryControlOnLeft = true; +-// ++// + primaryControlOnLeft = false; + // + +diff --git a/src/3rdparty/chromium/components/network_session_configurator/browser/network_session_configurator.cc b/src/3rdparty/chromium/components/network_session_configurator/browser/network_session_configurator.cc +index 92e039b..972e4a4 100644 +--- a/src/3rdparty/chromium/components/network_session_configurator/browser/network_session_configurator.cc ++++ b/src/3rdparty/chromium/components/network_session_configurator/browser/network_session_configurator.cc +@@ -719,7 +719,7 @@ net::URLRequestContextBuilder::HttpCacheParams::Type ChooseCacheType() { + } + #endif // #if !defined(OS_ANDROID) + +-#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_CHROMEOS) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_HAIKU) + return net::URLRequestContextBuilder::HttpCacheParams::DISK_SIMPLE; + #else + return net::URLRequestContextBuilder::HttpCacheParams::DISK_BLOCKFILE; +diff --git a/src/3rdparty/chromium/components/plugins/renderer/plugin_placeholder.cc b/src/3rdparty/chromium/components/plugins/renderer/plugin_placeholder.cc +index 93db78a..438bd67 100644 +--- a/src/3rdparty/chromium/components/plugins/renderer/plugin_placeholder.cc ++++ b/src/3rdparty/chromium/components/plugins/renderer/plugin_placeholder.cc +@@ -17,7 +17,11 @@ + #include "third_party/blink/public/web/web_plugin_container.h" + #include "third_party/blink/public/web/web_script_source.h" + #include "third_party/blink/public/web/web_serialized_script_value.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif // defined(OS_HAIKU) + + namespace plugins { + +diff --git a/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.cc b/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.cc +index 0bc46cd..9984e95 100644 +--- a/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.cc ++++ b/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.cc +@@ -10,7 +10,7 @@ namespace storage_monitor { + const char kFSUniqueIdPrefix[] = "UUID:"; + const char kVendorModelSerialPrefix[] = "VendorModelSerial:"; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const char kVendorModelVolumeStoragePrefix[] = "VendorModelVolumeStorage:"; + #endif + +diff --git a/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.h b/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.h +index 97a059f..73fc798 100644 +--- a/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.h ++++ b/src/3rdparty/chromium/components/storage_monitor/removable_device_constants.h +@@ -15,7 +15,7 @@ namespace storage_monitor { + extern const char kFSUniqueIdPrefix[]; + extern const char kVendorModelSerialPrefix[]; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + extern const char kVendorModelVolumeStoragePrefix[]; + #endif + +diff --git a/src/3rdparty/chromium/components/update_client/update_query_params.cc b/src/3rdparty/chromium/components/update_client/update_query_params.cc +index 56aea40..83c9ea5 100644 +--- a/src/3rdparty/chromium/components/update_client/update_query_params.cc ++++ b/src/3rdparty/chromium/components/update_client/update_query_params.cc +@@ -39,6 +39,8 @@ const char kOs[] = + "fuchsia"; + #elif defined(OS_OPENBSD) + "openbsd"; ++#elif defined(OS_HAIKU) ++ "haiku"; + #else + #error "unknown os" + #endif +diff --git a/src/3rdparty/chromium/components/url_matcher/regex_set_matcher.cc b/src/3rdparty/chromium/components/url_matcher/regex_set_matcher.cc +index d3d2279..29a074f 100644 +--- a/src/3rdparty/chromium/components/url_matcher/regex_set_matcher.cc ++++ b/src/3rdparty/chromium/components/url_matcher/regex_set_matcher.cc +@@ -12,8 +12,13 @@ + #include "base/logging.h" + #include "base/strings/string_util.h" + #include "components/url_matcher/substring_set_matcher.h" ++#if defined(OS_HAIKU) ++#include ++#include ++#else + #include "third_party/re2/src/re2/filtered_re2.h" + #include "third_party/re2/src/re2/re2.h" ++#endif + + namespace url_matcher { + +diff --git a/src/3rdparty/chromium/components/url_matcher/url_matcher_factory.cc b/src/3rdparty/chromium/components/url_matcher/url_matcher_factory.cc +index fe676dd..ff3577f 100644 +--- a/src/3rdparty/chromium/components/url_matcher/url_matcher_factory.cc ++++ b/src/3rdparty/chromium/components/url_matcher/url_matcher_factory.cc +@@ -16,7 +16,11 @@ + #include "base/values.h" + #include "components/url_matcher/url_matcher_constants.h" + #include "components/url_matcher/url_matcher_helpers.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + namespace url_matcher { + +diff --git a/src/3rdparty/chromium/components/webcrypto/algorithms/test_helpers.cc b/src/3rdparty/chromium/components/webcrypto/algorithms/test_helpers.cc +index 4ca7898..ba57aca 100644 +--- a/src/3rdparty/chromium/components/webcrypto/algorithms/test_helpers.cc ++++ b/src/3rdparty/chromium/components/webcrypto/algorithms/test_helpers.cc +@@ -25,7 +25,11 @@ + #include "components/webcrypto/status.h" + #include "third_party/blink/public/platform/web_crypto_algorithm_params.h" + #include "third_party/blink/public/platform/web_crypto_key_algorithm.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + namespace webcrypto { + +diff --git a/src/3rdparty/chromium/content/browser/browser_main_loop.cc b/src/3rdparty/chromium/content/browser/browser_main_loop.cc +index 42acf7a..f3767a8 100644 +--- a/src/3rdparty/chromium/content/browser/browser_main_loop.cc ++++ b/src/3rdparty/chromium/content/browser/browser_main_loop.cc +@@ -247,6 +247,13 @@ + #include "mojo/public/cpp/bindings/lib/test_random_mojo_delays.h" + #endif + ++#if defined(OS_HAIKU) ++#include "content/browser/sandbox_host_linux.h" ++#include "services/service_manager/zygote/common/common_sandbox_support_linux.h" ++#include "content/public/common/common_sandbox_support_linux.h" ++#include "services/service_manager/sandbox/sandbox.h" ++#endif ++ + // One of the linux specific headers defines this as a macro. + #ifdef DestroyAll + #undef DestroyAll +@@ -665,7 +672,7 @@ int BrowserMainLoop::EarlyInitialization() { + } + #endif // !defined(OS_MACOSX) + +-#if defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_CHROMEOS) || \ ++#if defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_HAIKU) || \ + defined(OS_ANDROID) + // We use quite a few file descriptors for our IPC as well as disk the disk + // cache,and the default limit on the Mac is low (256), so bump it up. +@@ -675,7 +682,7 @@ int BrowserMainLoop::EarlyInitialization() { + // users can easily hit this limit with many open tabs. Bump up the limit to + // an arbitrarily high number. See https://crbug.com/539567 + base::IncreaseFdLimitTo(8192); +-#endif // defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_CHROMEOS) || ++#endif // defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_CHROMEOS) || defined(OS_HAIKU) || + // defined(OS_ANDROID) + + #if defined(OS_WIN) +diff --git a/src/3rdparty/chromium/content/browser/devtools/protocol/system_info_handler.cc b/src/3rdparty/chromium/content/browser/devtools/protocol/system_info_handler.cc +index c635c85..6f99fc3 100644 +--- a/src/3rdparty/chromium/content/browser/devtools/protocol/system_info_handler.cc ++++ b/src/3rdparty/chromium/content/browser/devtools/protocol/system_info_handler.cc +@@ -48,7 +48,7 @@ std::unique_ptr GfxSizeToSystemInfoSize( + // Give the GPU process a few seconds to provide GPU info. + // Linux Debug builds need more time -- see Issue 796437. + // Windows builds need more time -- see Issue 873112 and 1004472. +-#if (defined(OS_LINUX) && !defined(NDEBUG)) ++#if ((defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(NDEBUG)) + const int kGPUInfoWatchdogTimeoutMs = 20000; + #elif defined(OS_WIN) + const int kGPUInfoWatchdogTimeoutMs = 30000; +diff --git a/src/3rdparty/chromium/content/browser/gpu/gpu_process_host.cc b/src/3rdparty/chromium/content/browser/gpu/gpu_process_host.cc +index b905d97..50fdfe5 100644 +--- a/src/3rdparty/chromium/content/browser/gpu/gpu_process_host.cc ++++ b/src/3rdparty/chromium/content/browser/gpu/gpu_process_host.cc +@@ -1095,7 +1095,7 @@ bool GpuProcessHost::LaunchGpuProcess() { + std::unique_ptr cmd_line = + std::make_unique(base::CommandLine::NO_PROGRAM); + #else +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + int child_flags = gpu_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF + : ChildProcessHost::CHILD_NORMAL; + #elif defined(OS_MACOSX) +diff --git a/src/3rdparty/chromium/content/browser/media/media_internals.cc b/src/3rdparty/chromium/content/browser/media/media_internals.cc +index c2775b3..ce538f8 100644 +--- a/src/3rdparty/chromium/content/browser/media/media_internals.cc ++++ b/src/3rdparty/chromium/content/browser/media/media_internals.cc +@@ -560,7 +560,7 @@ void MediaInternals::UpdateVideoCaptureDeviceCapabilities( + device_dict->SetString("id", descriptor.device_id); + device_dict->SetString("name", descriptor.GetNameAndModel()); + device_dict->Set("formats", std::move(format_list)); +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || \ ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) || \ + defined(OS_ANDROID) + device_dict->SetString("captureApi", descriptor.GetCaptureApiTypeString()); + #endif +diff --git a/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host.cc b/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host.cc +index 0fa99dc..1cfc1bf 100644 +--- a/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host.cc ++++ b/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host.cc +@@ -365,7 +365,7 @@ bool PpapiPluginProcessHost::Init(const PepperPluginInfo& info) { + base::CommandLine::StringType plugin_launcher = + browser_command_line.GetSwitchValueNative(switches::kPpapiPluginLauncher); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + int flags = plugin_launcher.empty() ? ChildProcessHost::CHILD_ALLOW_SELF : + ChildProcessHost::CHILD_NORMAL; + #elif defined(OS_MACOSX) +diff --git a/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host_receiver_bindings.cc b/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host_receiver_bindings.cc +index 28bac36..bdd1ee0 100644 +--- a/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host_receiver_bindings.cc ++++ b/src/3rdparty/chromium/content/browser/ppapi_plugin_process_host_receiver_bindings.cc +@@ -8,7 +8,7 @@ + + #include "build/build_config.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "components/services/font/public/mojom/font_service.mojom.h" // nogncheck + #include "content/browser/font_service.h" // nogncheck + #endif +@@ -17,7 +17,7 @@ namespace content { + + void PpapiPluginProcessHost::BindHostReceiver( + mojo::GenericPendingReceiver receiver) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (auto font_receiver = receiver.As()) + ConnectToFontService(std::move(font_receiver)); + #endif +diff --git a/src/3rdparty/chromium/content/browser/renderer_host/input/input_device_change_observer.cc b/src/3rdparty/chromium/content/browser/renderer_host/input/input_device_change_observer.cc +index 8280ecc..d7981bc 100644 +--- a/src/3rdparty/chromium/content/browser/renderer_host/input/input_device_change_observer.cc ++++ b/src/3rdparty/chromium/content/browser/renderer_host/input/input_device_change_observer.cc +@@ -10,7 +10,7 @@ + + #if defined(OS_WIN) + #include "ui/events/devices/input_device_observer_win.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #include "ui/events/devices/device_data_manager.h" + #elif defined(OS_ANDROID) + #include "ui/events/devices/input_device_observer_android.h" +@@ -22,7 +22,7 @@ InputDeviceChangeObserver::InputDeviceChangeObserver(RenderViewHostImpl* rvhi) { + render_view_host_impl_ = rvhi; + #if defined(OS_WIN) + ui::InputDeviceObserverWin::GetInstance()->AddObserver(this); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + ui::DeviceDataManager::GetInstance()->AddObserver(this); + #elif defined(OS_ANDROID) + ui::InputDeviceObserverAndroid::GetInstance()->AddObserver(this); +@@ -32,7 +32,7 @@ InputDeviceChangeObserver::InputDeviceChangeObserver(RenderViewHostImpl* rvhi) { + InputDeviceChangeObserver::~InputDeviceChangeObserver() { + #if defined(OS_WIN) + ui::InputDeviceObserverWin::GetInstance()->RemoveObserver(this); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + ui::DeviceDataManager::GetInstance()->RemoveObserver(this); + #elif defined(OS_ANDROID) + ui::InputDeviceObserverAndroid::GetInstance()->RemoveObserver(this); +diff --git a/src/3rdparty/chromium/content/browser/renderer_host/pepper/pepper_file_io_host.cc b/src/3rdparty/chromium/content/browser/renderer_host/pepper/pepper_file_io_host.cc +index bd68358..e74d9aa 100644 +--- a/src/3rdparty/chromium/content/browser/renderer_host/pepper/pepper_file_io_host.cc ++++ b/src/3rdparty/chromium/content/browser/renderer_host/pepper/pepper_file_io_host.cc +@@ -433,7 +433,7 @@ void PepperFileIOHost::OnLocalFileOpened( + ppapi::host::ReplyMessageContext reply_context, + const base::FilePath& path, + base::File::Error error_code) { +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + // Quarantining a file before its contents are available is only supported on + // Windows and Linux. + if (!FileOpenForWrite(open_flags_) || error_code != base::File::FILE_OK) { +@@ -454,7 +454,7 @@ void PepperFileIOHost::OnLocalFileOpened( + #endif + } + +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + void PepperFileIOHost::OnLocalFileQuarantined( + ppapi::host::ReplyMessageContext reply_context, + const base::FilePath& path, +diff --git a/src/3rdparty/chromium/content/browser/renderer_host/render_view_host_impl.cc b/src/3rdparty/chromium/content/browser/renderer_host/render_view_host_impl.cc +index 01a4e3d..02198ae 100644 +--- a/src/3rdparty/chromium/content/browser/renderer_host/render_view_host_impl.cc ++++ b/src/3rdparty/chromium/content/browser/renderer_host/render_view_host_impl.cc +@@ -206,7 +206,7 @@ void RenderViewHostImpl::GetPlatformSpecificPrefs( + display::win::ScreenWin::GetSystemMetricsInDIP(SM_CYVSCROLL); + prefs->arrow_bitmap_width_horizontal_scroll_bar_in_dips = + display::win::ScreenWin::GetSystemMetricsInDIP(SM_CXHSCROLL); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + prefs->system_font_family_name = gfx::Font().GetFontName(); + #elif defined(OS_FUCHSIA) + // Make Blink's "focus ring" invisible. The focus ring is a hairline border +diff --git a/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_aura.cc b/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_aura.cc +index 423aefb..6b197c0 100644 +--- a/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_aura.cc ++++ b/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_aura.cc +@@ -115,7 +115,7 @@ + #include "content/browser/accessibility/browser_accessibility_auralinux.h" + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_HAIKU) || defined(OS_LINUX)) && !defined(OS_CHROMEOS) + #include "ui/base/ime/linux/text_edit_command_auralinux.h" + #include "ui/base/ime/linux/text_edit_key_bindings_delegate_auralinux.h" + #endif +@@ -2187,7 +2187,7 @@ bool RenderWidgetHostViewAura::NeedsInputGrab() { + } + + bool RenderWidgetHostViewAura::NeedsMouseCapture() { +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_HAIKU) || defined(OS_LINUX)) && !defined(OS_CHROMEOS) + return NeedsInputGrab(); + #else + return false; +@@ -2357,7 +2357,7 @@ void RenderWidgetHostViewAura::ForwardKeyboardEventWithLatencyInfo( + if (!target_host) + return; + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_HAIKU) || defined(OS_LINUX)) && !defined(OS_CHROMEOS) + ui::TextEditKeyBindingsDelegateAuraLinux* keybinding_delegate = + ui::GetTextEditKeyBindingsDelegate(); + std::vector commands; +diff --git a/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc b/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc +index 4b2067b..092b80d 100644 +--- a/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc ++++ b/src/3rdparty/chromium/content/browser/renderer_host/render_widget_host_view_event_handler.cc +@@ -641,7 +641,7 @@ bool RenderWidgetHostViewEventHandler::CanRendererHandleEvent( + if (event->type() == ui::ET_MOUSE_EXITED) { + if (mouse_locked || selection_popup) + return false; +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + // Don't forward the mouse leave message which is received when the context + // menu is displayed by the page. This confuses the page and causes state + // changes. +diff --git a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/jank_monitor.cc b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/jank_monitor.cc +index 288fe15..0fc06c4 100644 +--- a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/jank_monitor.cc ++++ b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/jank_monitor.cc +@@ -322,7 +322,7 @@ void JankMonitor::ThreadExecutionState::DidRunTaskOrEvent( + // in context menus, among others). Simply ignore the mismatches for now. + // See https://crbug.com/929813 for the details of why the mismatch + // happens. +-#if !defined(OS_CHROMEOS) && defined(OS_LINUX) && defined(USE_OZONE) ++#if !defined(OS_CHROMEOS) && (defined(OS_LINUX) || defined(OS_HAIKU)) && defined(USE_OZONE) + task_execution_metadata_.clear(); + #endif + return; +diff --git a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.cc b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.cc +index ff9f906..b1073b6 100644 +--- a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.cc ++++ b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.cc +@@ -15,7 +15,7 @@ + + #include "ui/events/platform/platform_event_source.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "ui/aura/env.h" + #include "ui/events/event.h" + #endif +@@ -39,7 +39,7 @@ NativeEventObserver::~NativeEventObserver() { + DeregisterObserver(); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + void NativeEventObserver::RegisterObserver() { + aura::Env::GetInstance()->AddWindowEventDispatcherObserver(this); + } +@@ -61,7 +61,7 @@ void NativeEventObserver::OnWindowEventDispatcherFinishedProcessingEvent( + did_run_event_callback_.Run(info.unique_id); + events_being_processed_.pop_back(); + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + #if defined(OS_WIN) + void NativeEventObserver::RegisterObserver() { +diff --git a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.h b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.h +index 84b4f71..e4b46a8 100644 +--- a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.h ++++ b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/native_event_observer.h +@@ -14,7 +14,7 @@ + #include "content/public/browser/native_event_processor_observer_mac.h" + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "ui/aura/window_event_dispatcher_observer.h" + #endif + +@@ -39,7 +39,7 @@ namespace responsiveness { + class CONTENT_EXPORT NativeEventObserver + #if defined(OS_MACOSX) + : public NativeEventProcessorObserver +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + : public aura::WindowEventDispatcherObserver + #elif defined(OS_WIN) + : public base::MessagePumpForUI::Observer +@@ -56,7 +56,7 @@ class CONTENT_EXPORT NativeEventObserver + NativeEventObserver(WillRunEventCallback will_run_event_callback, + DidRunEventCallback did_run_event_callback); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + ~NativeEventObserver() override; + #else + virtual ~NativeEventObserver(); +@@ -68,7 +68,7 @@ class CONTENT_EXPORT NativeEventObserver + // Exposed for tests. + void WillRunNativeEvent(const void* opaque_identifier) override; + void DidRunNativeEvent(const void* opaque_identifier) override; +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + // aura::WindowEventDispatcherObserver overrides: + void OnWindowEventDispatcherStartedProcessing( + aura::WindowEventDispatcher* dispatcher, +@@ -85,7 +85,7 @@ class CONTENT_EXPORT NativeEventObserver + void RegisterObserver(); + void DeregisterObserver(); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + struct EventInfo { + const void* unique_id; + }; +diff --git a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/watcher.cc b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/watcher.cc +index 4f4a6e4..4359241 100644 +--- a/src/3rdparty/chromium/content/browser/scheduler/responsiveness/watcher.cc ++++ b/src/3rdparty/chromium/content/browser/scheduler/responsiveness/watcher.cc +@@ -101,7 +101,7 @@ void Watcher::DidRunTask(const base::PendingTask* task, + // in context menus, among others). Simply ignore the mismatches for now. + // See https://crbug.com/929813 for the details of why the mismatch + // happens. +-#if !defined(OS_CHROMEOS) && defined(OS_LINUX) && defined(USE_OZONE) ++#if !defined(OS_CHROMEOS) && (defined(OS_LINUX) || defined(OS_HAIKU)) && defined(USE_OZONE) + return currently_running_metadata_ui_.clear(); + #endif + DCHECK_LE(*mismatched_task_identifiers, 1); +@@ -170,7 +170,7 @@ void Watcher::DidRunEventOnUIThread(const void* opaque_identifier) { + mismatched_event_identifiers_ui_ += 1; + // See comment in DidRunTask() for why |currently_running_metadata_ui_| may + // be reset. +-#if !defined(OS_CHROMEOS) && defined(OS_LINUX) && defined(USE_OZONE) ++#if !defined(OS_CHROMEOS) && (defined(OS_LINUX) || defined(OS_HAIKU)) && defined(USE_OZONE) + return currently_running_metadata_ui_.clear(); + #endif + DCHECK_LE(mismatched_event_identifiers_ui_, 1); +diff --git a/src/3rdparty/chromium/content/browser/utility_process_host.cc b/src/3rdparty/chromium/content/browser/utility_process_host.cc +index cb85b9e..bd372f8 100644 +--- a/src/3rdparty/chromium/content/browser/utility_process_host.cc ++++ b/src/3rdparty/chromium/content/browser/utility_process_host.cc +@@ -247,7 +247,7 @@ UtilityProcessHost::UtilityProcessHost() + + UtilityProcessHost::UtilityProcessHost(std::unique_ptr client) + : sandbox_type_(service_manager::SandboxType::kUtility), +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + child_flags_(ChildProcessHost::CHILD_ALLOW_SELF), + #else + child_flags_(ChildProcessHost::CHILD_NORMAL), +diff --git a/src/3rdparty/chromium/content/browser/utility_process_host_receiver_bindings.cc b/src/3rdparty/chromium/content/browser/utility_process_host_receiver_bindings.cc +index d25a0e0..f47de8f 100644 +--- a/src/3rdparty/chromium/content/browser/utility_process_host_receiver_bindings.cc ++++ b/src/3rdparty/chromium/content/browser/utility_process_host_receiver_bindings.cc +@@ -8,7 +8,7 @@ + + #include "build/build_config.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "components/services/font/public/mojom/font_service.mojom.h" // nogncheck + #include "content/browser/font_service.h" // nogncheck + #endif +@@ -17,7 +17,7 @@ namespace content { + + void UtilityProcessHost::BindHostReceiver( + mojo::GenericPendingReceiver receiver) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (auto font_receiver = receiver.As()) { + ConnectToFontService(std::move(font_receiver)); + return; +diff --git a/src/3rdparty/chromium/content/browser/v8_snapshot_files.cc b/src/3rdparty/chromium/content/browser/v8_snapshot_files.cc +index a09a551..ecc4376 100644 +--- a/src/3rdparty/chromium/content/browser/v8_snapshot_files.cc ++++ b/src/3rdparty/chromium/content/browser/v8_snapshot_files.cc +@@ -10,7 +10,7 @@ + namespace content { + + std::map GetV8SnapshotFilesToPreload() { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #if defined(USE_V8_CONTEXT_SNAPSHOT) + return {{kV8ContextSnapshotDataDescriptor, + base::FilePath(FILE_PATH_LITERAL("v8_context_snapshot.bin"))}}; +diff --git a/src/3rdparty/chromium/content/browser/webui/shared_resources_data_source.cc b/src/3rdparty/chromium/content/browser/webui/shared_resources_data_source.cc +index 69fe841..7679a2a 100644 +--- a/src/3rdparty/chromium/content/browser/webui/shared_resources_data_source.cc ++++ b/src/3rdparty/chromium/content/browser/webui/shared_resources_data_source.cc +@@ -131,12 +131,12 @@ const std::map CreateMojoResourceIdToAliasMap() { + "mojo/mojo/public/mojom/base/text_direction.mojom.html"}, + {IDR_MOJO_TEXT_DIRECTION_MOJOM_LITE_JS, + "mojo/mojo/public/mojom/base/text_direction.mojom-lite.js"}, +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + {IDR_MOJO_TIME_MOJOM_HTML, + "mojo/mojo/public/mojom/base/time.mojom.html"}, + {IDR_MOJO_TIME_MOJOM_LITE_JS, + "mojo/mojo/public/mojom/base/time.mojom-lite.js"}, +-#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + }; + } + +diff --git a/src/3rdparty/chromium/content/common/BUILD.gn b/src/3rdparty/chromium/content/common/BUILD.gn +index a67cc8e..cdaba6e 100644 +--- a/src/3rdparty/chromium/content/common/BUILD.gn ++++ b/src/3rdparty/chromium/content/common/BUILD.gn +@@ -346,6 +346,12 @@ static_library("common") { + libs += [ "android" ] + } + ++ if (is_haiku) { ++ sources -= [ ++ "sandbox_init_linux.cc", ++ ] ++ } ++ + if (is_debug && !is_component_build && enable_plugins) { + # Content depends on the PPAPI message logging stuff; if this isn't here, + # some unit test binaries won't compile. This only worked in release mode +diff --git a/src/3rdparty/chromium/content/common/user_agent.cc b/src/3rdparty/chromium/content/common/user_agent.cc +index 954209b..e70fefe 100644 +--- a/src/3rdparty/chromium/content/common/user_agent.cc ++++ b/src/3rdparty/chromium/content/common/user_agent.cc +@@ -160,6 +160,14 @@ std::string BuildOSCpuInfo(bool include_android_build_number) { + #endif + ); + ++#if defined(OS_HAIKU) ++#if defined(__x86_64__) ++ base::StringAppendF(&os_cpu, "; Linux x86_64"); ++#else ++ base::StringAppendF(&os_cpu, "; Linux i686"); ++#endif ++#endif ++ + return os_cpu; + } + +diff --git a/src/3rdparty/chromium/content/gpu/gpu_main.cc b/src/3rdparty/chromium/content/gpu/gpu_main.cc +index 004fa37..1d10994 100644 +--- a/src/3rdparty/chromium/content/gpu/gpu_main.cc ++++ b/src/3rdparty/chromium/content/gpu/gpu_main.cc +@@ -84,7 +84,7 @@ + #include "ui/gfx/x/x11_switches.h" // nogncheck + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "content/gpu/gpu_sandbox_hook_linux.h" + #include "content/public/common/sandbox_init.h" + #include "services/service_manager/sandbox/linux/sandbox_linux.h" +@@ -109,7 +109,7 @@ namespace content { + + namespace { + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) && !defined(OS_HAIKU) + bool StartSandboxLinux(gpu::GpuWatchdogThread*, + const gpu::GPUInfo*, + const gpu::GpuPreferences&); +@@ -162,7 +162,7 @@ class ContentSandboxHelper : public gpu::GpuSandboxHelper { + bool EnsureSandboxInitialized(gpu::GpuWatchdogThread* watchdog_thread, + const gpu::GPUInfo* gpu_info, + const gpu::GpuPreferences& gpu_prefs) override { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) && !defined(OS_HAIKU) + return StartSandboxLinux(watchdog_thread, gpu_info, gpu_prefs); + #elif defined(OS_WIN) + return StartSandboxWindows(sandbox_info_); +@@ -290,7 +290,7 @@ int GpuMain(const MainFunctionParams& parameters) { + main_thread_task_executor = + std::make_unique( + gpu_preferences.message_pump_type); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #error "Unsupported Linux platform." + #elif defined(OS_MACOSX) + // Cross-process CoreAnimation requires a CFRunLoop to function at all, and +@@ -436,7 +436,7 @@ int GpuMain(const MainFunctionParams& parameters) { + + namespace { + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) && !defined(OS_HAIKU) + bool StartSandboxLinux(gpu::GpuWatchdogThread* watchdog_thread, + const gpu::GPUInfo* gpu_info, + const gpu::GpuPreferences& gpu_prefs) { +@@ -473,7 +473,7 @@ bool StartSandboxLinux(gpu::GpuWatchdogThread* watchdog_thread, + + return res; + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) && !defined(OS_HAIKU) + + #if defined(OS_WIN) + bool StartSandboxWindows(const sandbox::SandboxInterfaceInfo* sandbox_info) { +diff --git a/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.cc b/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.cc +index 1a81714..2eff867 100644 +--- a/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.cc ++++ b/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.cc +@@ -19,7 +19,7 @@ + + #if defined(OS_MACOSX) + #include "content/child/child_process_sandbox_support_impl_mac.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #include "content/child/child_process_sandbox_support_impl_linux.h" + #include "mojo/public/cpp/bindings/pending_remote.h" + #endif +@@ -34,7 +34,7 @@ typedef struct CGFont* CGFontRef; + namespace content { + + PpapiBlinkPlatformImpl::PpapiBlinkPlatformImpl() { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + mojo::PendingRemote font_service; + ChildThread::Get()->BindHostReceiver( + font_service.InitWithNewPipeAndPassReceiver()); +@@ -52,7 +52,7 @@ PpapiBlinkPlatformImpl::~PpapiBlinkPlatformImpl() { + void PpapiBlinkPlatformImpl::Shutdown() {} + + blink::WebSandboxSupport* PpapiBlinkPlatformImpl::GetSandboxSupport() { +-#if defined(OS_LINUX) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + return sandbox_support_.get(); + #else + return nullptr; +diff --git a/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.h b/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.h +index 45f4a23..717fdfc 100644 +--- a/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.h ++++ b/src/3rdparty/chromium/content/ppapi_plugin/ppapi_blink_platform_impl.h +@@ -13,7 +13,7 @@ + #include "build/build_config.h" + #include "content/child/blink_platform_impl.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "components/services/font/public/cpp/font_loader.h" + #include "third_party/skia/include/core/SkRefCnt.h" + #endif +@@ -36,11 +36,11 @@ class PpapiBlinkPlatformImpl : public BlinkPlatformImpl { + blink::WebThemeEngine* ThemeEngine() override; + + private: +-#if defined(OS_LINUX) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + std::unique_ptr sandbox_support_; + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + sk_sp font_loader_; + #endif + +diff --git a/src/3rdparty/chromium/content/public/app/content_main_delegate.cc b/src/3rdparty/chromium/content/public/app/content_main_delegate.cc +index af1200a..f81f1e2 100644 +--- a/src/3rdparty/chromium/content/public/app/content_main_delegate.cc ++++ b/src/3rdparty/chromium/content/public/app/content_main_delegate.cc +@@ -27,13 +27,13 @@ int ContentMainDelegate::RunProcess( + return -1; + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + + void ContentMainDelegate::ZygoteStarting( + std::vector>* + delegates) {} + +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + int ContentMainDelegate::TerminateForFatalInitializationError() { + CHECK(false); +diff --git a/src/3rdparty/chromium/content/public/app/content_main_delegate.h b/src/3rdparty/chromium/content/public/app/content_main_delegate.h +index f859064..1c991bb 100644 +--- a/src/3rdparty/chromium/content/public/app/content_main_delegate.h ++++ b/src/3rdparty/chromium/content/public/app/content_main_delegate.h +@@ -60,7 +60,7 @@ class CONTENT_EXPORT ContentMainDelegate { + // Called right before the process exits. + virtual void ProcessExiting(const std::string& process_type) {} + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Tells the embedder that the zygote process is starting, and allows it to + // specify one or more zygote delegates if it wishes by storing them in + // |*delegates|. +@@ -70,7 +70,7 @@ class CONTENT_EXPORT ContentMainDelegate { + + // Called every time the zygote process forks. + virtual void ZygoteForked() {} +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + // Fatal errors during initialization are reported by this function, so that + // the embedder can implement graceful exit by displaying some message and +diff --git a/src/3rdparty/chromium/content/public/common/common_param_traits_macros.h b/src/3rdparty/chromium/content/public/common/common_param_traits_macros.h +index 8245e29..2066d3d 100644 +--- a/src/3rdparty/chromium/content/public/common/common_param_traits_macros.h ++++ b/src/3rdparty/chromium/content/public/common/common_param_traits_macros.h +@@ -313,7 +313,7 @@ IPC_STRUCT_TRAITS_BEGIN(blink::mojom::RendererPreferences) + IPC_STRUCT_TRAITS_MEMBER(accept_languages) + IPC_STRUCT_TRAITS_MEMBER(disable_client_blocked_error_page) + IPC_STRUCT_TRAITS_MEMBER(plugin_fullscreen_allowed) +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + IPC_STRUCT_TRAITS_MEMBER(system_font_family_name) + #endif + #if defined(OS_WIN) +diff --git a/src/3rdparty/chromium/content/public/common/content_constants.cc b/src/3rdparty/chromium/content/public/common/content_constants.cc +index 4fd4097..a8c448b 100644 +--- a/src/3rdparty/chromium/content/public/common/content_constants.cc ++++ b/src/3rdparty/chromium/content/public/common/content_constants.cc +@@ -46,7 +46,7 @@ const int kDefaultDetachableCancelDelayMs = 30000; + const char kCorsExemptPurposeHeaderName[] = "Purpose"; + const char kCorsExemptRequestedWithHeaderName[] = "X-Requested-With"; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const int kLowestRendererOomScore = 300; + const int kHighestRendererOomScore = 1000; + +diff --git a/src/3rdparty/chromium/content/public/common/content_constants.h b/src/3rdparty/chromium/content/public/common/content_constants.h +index 478cbf0..b68bb21 100644 +--- a/src/3rdparty/chromium/content/public/common/content_constants.h ++++ b/src/3rdparty/chromium/content/public/common/content_constants.h +@@ -65,7 +65,7 @@ CONTENT_EXPORT extern const int kDefaultDetachableCancelDelayMs; + CONTENT_EXPORT extern const char kCorsExemptPurposeHeaderName[]; + CONTENT_EXPORT extern const char kCorsExemptRequestedWithHeaderName[]; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // The OOM score adj constants + // The highest and lowest assigned OOM score adjustment (oom_score_adj) for + // renderers and extensions used by the OomPriority Manager. +diff --git a/src/3rdparty/chromium/content/public/common/content_features.cc b/src/3rdparty/chromium/content/public/common/content_features.cc +index 339b3d2..c6239ca 100644 +--- a/src/3rdparty/chromium/content/public/common/content_features.cc ++++ b/src/3rdparty/chromium/content/public/common/content_features.cc +@@ -49,7 +49,7 @@ const base::Feature kAudioServiceLaunchOnStartup{ + const base::Feature kAudioServiceOutOfProcess { + "AudioServiceOutOfProcess", + #if defined(OS_WIN) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + base::FEATURE_ENABLED_BY_DEFAULT + #else + base::FEATURE_DISABLED_BY_DEFAULT +@@ -717,7 +717,7 @@ const base::Feature kWebAssemblyThreads { + }; + + // Enable WebAssembly trap handler. +-#if (defined(OS_LINUX) || defined(OS_WIN) || defined(OS_MACOSX)) && \ ++#if (defined(OS_HAIKU) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_MACOSX)) && \ + defined(ARCH_CPU_X86_64) + const base::Feature kWebAssemblyTrapHandler{"WebAssemblyTrapHandler", + base::FEATURE_ENABLED_BY_DEFAULT}; +@@ -747,7 +747,7 @@ const base::Feature kWebAuth{"WebAuthentication", + // https://w3c.github.io/webauthn + const base::Feature kWebAuthCable { + "WebAuthenticationCable", +-#if !defined(OS_CHROMEOS) && defined(OS_LINUX) ++#if (!defined(OS_CHROMEOS) && defined(OS_LINUX)) || defined(OS_HAIKU) + base::FEATURE_DISABLED_BY_DEFAULT + #else + base::FEATURE_ENABLED_BY_DEFAULT +diff --git a/src/3rdparty/chromium/content/public/common/content_switches.cc b/src/3rdparty/chromium/content/public/common/content_switches.cc +index d251e1d..fdbb091 100644 +--- a/src/3rdparty/chromium/content/public/common/content_switches.cc ++++ b/src/3rdparty/chromium/content/public/common/content_switches.cc +@@ -1005,7 +1005,7 @@ const char kEnableAggressiveDOMStorageFlushing[] = + // Enable indication that browser is controlled by automation. + const char kEnableAutomation[] = "enable-automation"; + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_FREEBSD) + // Allows sending text-to-speech requests to speech-dispatcher, a common + // Linux speech service. Because it's buggy, the user must explicitly + // enable it so that visiting a random webpage can't cause instability. +diff --git a/src/3rdparty/chromium/content/public/common/content_switches.h b/src/3rdparty/chromium/content/public/common/content_switches.h +index 252a0d0..5fb9d47 100644 +--- a/src/3rdparty/chromium/content/public/common/content_switches.h ++++ b/src/3rdparty/chromium/content/public/common/content_switches.h +@@ -286,7 +286,7 @@ CONTENT_EXPORT extern const char kRemoteDebuggingSocketName[]; + CONTENT_EXPORT extern const char kRendererWaitForJavaDebugger[]; + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_FREEBSD) + CONTENT_EXPORT extern const char kEnableSpeechDispatcher[]; + #endif + +diff --git a/src/3rdparty/chromium/content/public/common/use_zoom_for_dsf_policy.cc b/src/3rdparty/chromium/content/public/common/use_zoom_for_dsf_policy.cc +index 5519e07..8c1d4fc 100644 +--- a/src/3rdparty/chromium/content/public/common/use_zoom_for_dsf_policy.cc ++++ b/src/3rdparty/chromium/content/public/common/use_zoom_for_dsf_policy.cc +@@ -25,7 +25,7 @@ const base::Feature kUseZoomForDsfEnabledByDefault{ + #endif + + bool IsUseZoomForDSFEnabledByDefault() { +-#if defined(OS_LINUX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + return true; + #elif defined(OS_WIN) || defined(OS_ANDROID) + return base::FeatureList::IsEnabled(kUseZoomForDsfEnabledByDefault); +diff --git a/src/3rdparty/chromium/content/renderer/media/audio/audio_device_factory.cc b/src/3rdparty/chromium/content/renderer/media/audio/audio_device_factory.cc +index be41480..20317bf 100644 +--- a/src/3rdparty/chromium/content/renderer/media/audio/audio_device_factory.cc ++++ b/src/3rdparty/chromium/content/renderer/media/audio/audio_device_factory.cc +@@ -36,7 +36,7 @@ AudioDeviceFactory* AudioDeviceFactory::factory_ = nullptr; + namespace { + + #if defined(OS_WIN) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + // Due to driver deadlock issues on Windows (http://crbug/422522) there is a + // chance device authorization response is never received from the browser side. + // In this case we will time out, to avoid renderer hang forever waiting for +diff --git a/src/3rdparty/chromium/extensions/browser/api/declarative_webrequest/webrequest_action.cc b/src/3rdparty/chromium/extensions/browser/api/declarative_webrequest/webrequest_action.cc +index 2324fcc..2938493 100644 +--- a/src/3rdparty/chromium/extensions/browser/api/declarative_webrequest/webrequest_action.cc ++++ b/src/3rdparty/chromium/extensions/browser/api/declarative_webrequest/webrequest_action.cc +@@ -27,7 +27,11 @@ + #include "extensions/common/extension.h" + #include "net/base/registry_controlled_domains/registry_controlled_domain.h" + #include "net/http/http_util.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + using extension_web_request_api_helpers::EventResponseDelta; + +diff --git a/src/3rdparty/chromium/extensions/browser/api/messaging/message_service.cc b/src/3rdparty/chromium/extensions/browser/api/messaging/message_service.cc +index c391872..7eee6ac 100644 +--- a/src/3rdparty/chromium/extensions/browser/api/messaging/message_service.cc ++++ b/src/3rdparty/chromium/extensions/browser/api/messaging/message_service.cc +@@ -61,7 +61,7 @@ namespace { + + const char kReceivingEndDoesntExistError[] = + "Could not establish connection. Receiving end does not exist."; +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + const char kMissingPermissionError[] = + "Access to native messaging requires nativeMessaging permission."; + const char kProhibitedByPoliciesError[] = +@@ -391,7 +391,7 @@ void MessageService::OpenChannelToNativeApp( + if (!opener_port->IsValidPort()) + return; + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + bool has_permission = extension->permissions_data()->HasAPIPermission( + APIPermission::kNativeMessaging); + if (!has_permission) { +@@ -441,11 +441,11 @@ void MessageService::OpenChannelToNativeApp( + channel->opener->IncrementLazyKeepaliveCount(); + + AddChannel(std::move(channel), receiver_port_id); +-#else // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)) ++#else // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU)) + const char kNativeMessagingNotSupportedError[] = + "Native Messaging is not supported on this platform."; + opener_port->DispatchOnDisconnect(kNativeMessagingNotSupportedError); +-#endif // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)) ++#endif // !(defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU)) + } + + void MessageService::OpenChannelToTab(const ChannelEndpoint& source, +diff --git a/src/3rdparty/chromium/extensions/browser/api/networking_private/networking_private_delegate_factory.cc b/src/3rdparty/chromium/extensions/browser/api/networking_private/networking_private_delegate_factory.cc +index bd21efa..271d348 100644 +--- a/src/3rdparty/chromium/extensions/browser/api/networking_private/networking_private_delegate_factory.cc ++++ b/src/3rdparty/chromium/extensions/browser/api/networking_private/networking_private_delegate_factory.cc +@@ -11,7 +11,7 @@ + + #if defined(OS_CHROMEOS) + #include "extensions/browser/api/networking_private/networking_private_chromeos.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #include "extensions/browser/api/networking_private/networking_private_linux.h" + #elif defined(OS_WIN) || defined(OS_MACOSX) + #include "components/wifi/wifi_service.h" +@@ -61,7 +61,7 @@ KeyedService* NetworkingPrivateDelegateFactory::BuildServiceInstanceFor( + NetworkingPrivateDelegate* delegate; + #if defined(OS_CHROMEOS) + delegate = new NetworkingPrivateChromeOS(browser_context); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + delegate = new NetworkingPrivateLinux(); + #elif defined(OS_WIN) || defined(OS_MACOSX) + std::unique_ptr wifi_service(wifi::WiFiService::Create()); +diff --git a/src/3rdparty/chromium/extensions/browser/api/web_request/form_data_parser.cc b/src/3rdparty/chromium/extensions/browser/api/web_request/form_data_parser.cc +index bf41ae5..2b0e4f9 100644 +--- a/src/3rdparty/chromium/extensions/browser/api/web_request/form_data_parser.cc ++++ b/src/3rdparty/chromium/extensions/browser/api/web_request/form_data_parser.cc +@@ -15,7 +15,11 @@ + #include "base/values.h" + #include "net/base/escape.h" + #include "net/http/http_request_headers.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + using base::DictionaryValue; + using base::ListValue; +diff --git a/src/3rdparty/chromium/extensions/browser/browser_context_keyed_service_factories.cc b/src/3rdparty/chromium/extensions/browser/browser_context_keyed_service_factories.cc +index e32ab9d..d5bef7d 100644 +--- a/src/3rdparty/chromium/extensions/browser/browser_context_keyed_service_factories.cc ++++ b/src/3rdparty/chromium/extensions/browser/browser_context_keyed_service_factories.cc +@@ -81,7 +81,7 @@ void EnsureBrowserContextKeyedServiceFactoriesBuilt() { + IdleManagerFactory::GetInstance(); + #endif // !defined(TOOLKIT_QT) + ManagementAPI::GetFactoryInstance(); +-#if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_HAIKU) + NetworkingPrivateEventRouterFactory::GetInstance(); + #endif + PowerAPI::GetFactoryInstance(); +diff --git a/src/3rdparty/chromium/extensions/common/features/feature.cc b/src/3rdparty/chromium/extensions/common/features/feature.cc +index 29c05a6..5a7c919 100644 +--- a/src/3rdparty/chromium/extensions/common/features/feature.cc ++++ b/src/3rdparty/chromium/extensions/common/features/feature.cc +@@ -26,6 +26,8 @@ Feature::Platform Feature::GetCurrentPlatform() { + return MACOSX_PLATFORM; + #elif defined(OS_WIN) + return WIN_PLATFORM; ++#elif defined(OS_HAIKU) ++ return LINUX_PLATFORM; + #else + return UNSPECIFIED_PLATFORM; + #endif +diff --git a/src/3rdparty/chromium/extensions/common/image_util.cc b/src/3rdparty/chromium/extensions/common/image_util.cc +index e84bf58..11efcc3 100644 +--- a/src/3rdparty/chromium/extensions/common/image_util.cc ++++ b/src/3rdparty/chromium/extensions/common/image_util.cc +@@ -18,7 +18,11 @@ + #include "base/strings/stringprintf.h" + #include "base/time/time.h" + #include "base/timer/elapsed_timer.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif // defined(OS_HAIKU) + #include "third_party/skia/include/core/SkBitmap.h" + #include "third_party/skia/include/core/SkCanvas.h" + #include "third_party/skia/include/core/SkColor.h" +diff --git a/src/3rdparty/chromium/extensions/common/stack_frame.cc b/src/3rdparty/chromium/extensions/common/stack_frame.cc +index 497edac..19aa24f 100644 +--- a/src/3rdparty/chromium/extensions/common/stack_frame.cc ++++ b/src/3rdparty/chromium/extensions/common/stack_frame.cc +@@ -7,7 +7,11 @@ + #include + + #include "base/strings/utf_string_conversions.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + + namespace extensions { + +diff --git a/src/3rdparty/chromium/extensions/renderer/bindings/api_binding_util.cc b/src/3rdparty/chromium/extensions/renderer/bindings/api_binding_util.cc +index 3a95988..d3757c4 100644 +--- a/src/3rdparty/chromium/extensions/renderer/bindings/api_binding_util.cc ++++ b/src/3rdparty/chromium/extensions/renderer/bindings/api_binding_util.cc +@@ -129,6 +129,8 @@ std::string GetPlatformString() { + return "mac"; + #elif defined(OS_WIN) + return "win"; ++#elif defined(OS_HAIKU) ++ return "haiku"; + #else + NOTREACHED(); + return std::string(); +diff --git a/src/3rdparty/chromium/extensions/shell/app/shell_main_delegate.cc b/src/3rdparty/chromium/extensions/shell/app/shell_main_delegate.cc +index 27b627e..4d48440 100644 +--- a/src/3rdparty/chromium/extensions/shell/app/shell_main_delegate.cc ++++ b/src/3rdparty/chromium/extensions/shell/app/shell_main_delegate.cc +@@ -38,7 +38,7 @@ + + #if defined(OS_WIN) + #include "base/base_paths_win.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #include "base/nix/xdg_util.h" + #elif defined(OS_MACOSX) + #include "base/base_paths_mac.h" +@@ -70,7 +70,7 @@ base::FilePath GetDataPath() { + return cmd_line->GetSwitchValuePath(switches::kContentShellDataPath); + + base::FilePath data_dir; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + std::unique_ptr env(base::Environment::Create()); + data_dir = base::nix::GetXDGDirectory( + env.get(), base::nix::kXdgConfigHomeEnvVar, base::nix::kDotConfigDir); +diff --git a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.cc b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.cc +index 2108d54..631902b 100644 +--- a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.cc ++++ b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.cc +@@ -29,7 +29,7 @@ + #include "ui/gl/buildflags.h" + #include "ui/gl/gl_context.h" + +-#if defined(OS_LINUX) && BUILDFLAG(USE_DAWN) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(USE_DAWN) + #include "gpu/command_buffer/service/external_vk_image_dawn_representation.h" + #endif + +@@ -37,7 +37,7 @@ + #include "gpu/vulkan/fuchsia/vulkan_fuchsia_ext.h" + #endif + +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + #define GL_DEDICATED_MEMORY_OBJECT_EXT 0x9581 + #define GL_TEXTURE_TILING_EXT 0x9580 + #define GL_TILING_TYPES_EXT 0x9583 +@@ -510,7 +510,7 @@ std::unique_ptr + ExternalVkImageBacking::ProduceDawn(SharedImageManager* manager, + MemoryTypeTracker* tracker, + WGPUDevice wgpuDevice) { +-#if defined(OS_LINUX) && BUILDFLAG(USE_DAWN) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(USE_DAWN) + auto wgpu_format = viz::ToWGPUFormat(format()); + + if (wgpu_format == WGPUTextureFormat_Undefined) { +@@ -529,14 +529,14 @@ ExternalVkImageBacking::ProduceDawn(SharedImageManager* manager, + + return std::make_unique( + manager, this, tracker, wgpuDevice, wgpu_format, std::move(memory_fd)); +-#else // !defined(OS_LINUX) || !BUILDFLAG(USE_DAWN) ++#else // (!defined(OS_LINUX) && !defined(OS_HAIKU)) || !BUILDFLAG(USE_DAWN) + NOTIMPLEMENTED_LOG_ONCE(); + return nullptr; + #endif + } + + GLuint ExternalVkImageBacking::ProduceGLTextureInternal() { +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || \ ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || defined(OS_HAIKU) || \ + defined(OS_WIN) + GrVkImageInfo image_info; + bool result = backend_texture_.getVkImageInfo(&image_info); +@@ -545,7 +545,7 @@ GLuint ExternalVkImageBacking::ProduceGLTextureInternal() { + gl::GLApi* api = gl::g_current_gl_context; + GLuint memory_object = 0; + if (!use_separate_gl_texture()) { +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + auto memory_fd = image_->GetMemoryFd(); + if (!memory_fd.is_valid()) { + return 0; +@@ -608,7 +608,7 @@ GLuint ExternalVkImageBacking::ProduceGLTextureInternal() { + } + api->glBindTextureFn(GL_TEXTURE_2D, old_texture_binding); + return texture_service_id; +-#else // !defined(OS_LINUX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA) ++#else // !defined(OS_LINUX) && !defined(OS_ANDROID) && !defined(OS_FUCHSIA) && !defined(OS_HAIKU) + #error Unsupported OS + #endif + } +@@ -622,7 +622,7 @@ ExternalVkImageBacking::ProduceGLTexture(SharedImageManager* manager, + return nullptr; + } + +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || \ ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || defined(OS_HAIKU) || \ + defined(OS_WIN) + if (!texture_) { + GLuint texture_service_id = ProduceGLTextureInternal(); +@@ -666,7 +666,7 @@ ExternalVkImageBacking::ProduceGLTexturePassthrough( + return nullptr; + } + +-#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || \ ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_FUCHSIA) || defined(OS_HAIKU) || \ + defined(OS_WIN) + if (!texture_passthrough_) { + GLuint texture_service_id = ProduceGLTextureInternal(); +diff --git a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.h b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.h +index 6a612aa..5b6e9be 100644 +--- a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.h ++++ b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_backing.h +@@ -151,7 +151,7 @@ class ExternalVkImageBacking final : public ClearTrackingSharedImageBacking { + + private: + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + // Extract file descriptor from image + int GetMemoryFd(const GrVkImageInfo& image_info); + #endif +diff --git a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_gl_representation.cc b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_gl_representation.cc +index a1a5bbe..46111e8 100644 +--- a/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_gl_representation.cc ++++ b/src/3rdparty/chromium/gpu/command_buffer/service/external_vk_image_gl_representation.cc +@@ -188,7 +188,7 @@ GLuint ExternalVkImageGLRepresentationShared::ImportVkSemaphoreIntoGL( + SemaphoreHandle handle) { + if (!handle.is_valid()) + return 0; +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + if (handle.vk_handle_type() != + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) { + DLOG(ERROR) << "Importing semaphore handle of unexpected type:" +diff --git a/src/3rdparty/chromium/gpu/command_buffer/service/program_manager.cc b/src/3rdparty/chromium/gpu/command_buffer/service/program_manager.cc +index 4574d33..8e4508e 100644 +--- a/src/3rdparty/chromium/gpu/command_buffer/service/program_manager.cc ++++ b/src/3rdparty/chromium/gpu/command_buffer/service/program_manager.cc +@@ -30,7 +30,11 @@ + #include "gpu/command_buffer/service/program_cache.h" + #include "gpu/command_buffer/service/shader_manager.h" + #include "gpu/config/gpu_preferences.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif + #include "ui/gl/gl_version_info.h" + #include "ui/gl/progress_reporter.h" + +diff --git a/src/3rdparty/chromium/gpu/config/gpu_control_list.cc b/src/3rdparty/chromium/gpu/config/gpu_control_list.cc +index b4ab820..4565361 100644 +--- a/src/3rdparty/chromium/gpu/config/gpu_control_list.cc ++++ b/src/3rdparty/chromium/gpu/config/gpu_control_list.cc +@@ -16,7 +16,11 @@ + #include "base/values.h" + #include "build/build_config.h" + #include "gpu/config/gpu_util.h" ++#if defined(OS_HAIKU) ++#include ++#else + #include "third_party/re2/src/re2/re2.h" ++#endif // defined(OS_HAIKU) + + namespace gpu { + namespace { +@@ -221,7 +225,7 @@ bool GpuControlList::More::GLVersionInfoMismatch( + GpuControlList::GLType GpuControlList::More::GetDefaultGLType() { + #if defined(OS_CHROMEOS) + return kGLTypeGL; +-#elif defined(OS_LINUX) || defined(OS_OPENBSD) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + return kGLTypeGL; + #elif defined(OS_MACOSX) + return kGLTypeGL; +@@ -789,7 +793,7 @@ GpuControlList::OsType GpuControlList::GetOsType() { + return kOsAndroid; + #elif defined(OS_FUCHSIA) + return kOsFuchsia; +-#elif defined(OS_LINUX) || defined(OS_OPENBSD) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + return kOsLinux; + #elif defined(OS_MACOSX) + return kOsMacosx; +diff --git a/src/3rdparty/chromium/gpu/ipc/common/gpu_memory_buffer_support.h b/src/3rdparty/chromium/gpu/ipc/common/gpu_memory_buffer_support.h +index 2999e94..872b013 100644 +--- a/src/3rdparty/chromium/gpu/ipc/common/gpu_memory_buffer_support.h ++++ b/src/3rdparty/chromium/gpu/ipc/common/gpu_memory_buffer_support.h +@@ -16,7 +16,7 @@ + #include "ui/gfx/geometry/size.h" + #include "ui/gfx/gpu_memory_buffer.h" + +-#if defined(OS_LINUX) || defined(USE_OZONE) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(USE_OZONE) + namespace gfx { + class ClientNativePixmapFactory; + } +@@ -38,7 +38,7 @@ class GPU_EXPORT GpuMemoryBufferSupport { + bool IsNativeGpuMemoryBufferConfigurationSupported(gfx::BufferFormat format, + gfx::BufferUsage usage); + +-#if defined(OS_LINUX) || defined(USE_OZONE) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(USE_OZONE) + gfx::ClientNativePixmapFactory* client_native_pixmap_factory() { + return client_native_pixmap_factory_.get(); + } +@@ -62,7 +62,7 @@ class GPU_EXPORT GpuMemoryBufferSupport { + GpuMemoryBufferImpl::DestructionCallback callback); + + private: +-#if defined(OS_LINUX) || defined(USE_OZONE) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(USE_OZONE) + std::unique_ptr client_native_pixmap_factory_; + #endif + +diff --git a/src/3rdparty/chromium/gpu/ipc/service/gpu_init.cc b/src/3rdparty/chromium/gpu/ipc/service/gpu_init.cc +index 28ac206..3c66eb8 100644 +--- a/src/3rdparty/chromium/gpu/ipc/service/gpu_init.cc ++++ b/src/3rdparty/chromium/gpu/ipc/service/gpu_init.cc +@@ -92,7 +92,7 @@ void InitializePlatformOverlaySettings(GPUInfo* gpu_info) { + #endif + } + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && !BUILDFLAG(IS_CHROMECAST) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS) && !BUILDFLAG(IS_CHROMECAST)) || defined(OS_HAIKU) + bool CanAccessNvidiaDeviceFile() { + bool res = true; + base::ScopedBlockingCall scoped_blocking_call(FROM_HERE, +@@ -103,7 +103,7 @@ bool CanAccessNvidiaDeviceFile() { + } + return res; + } +-#endif // OS_LINUX && !OS_CHROMEOS && !BUILDFLAG(IS_CHROMECAST) ++#endif // (OS_LINUX && !OS_CHROMEOS && !BUILDFLAG(IS_CHROMECAST)) || defined(OS_HAIKU) + + class GpuWatchdogInit { + public: +@@ -161,7 +161,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + gpu_info_.subpixel_font_rendering = true; + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + if (gpu_info_.gpu.vendor_id == 0x10de && // NVIDIA + gpu_info_.gpu.driver_vendor == "NVIDIA" && !CanAccessNvidiaDeviceFile()) + return false; +@@ -213,7 +213,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + delayed_watchdog_enable = true; + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // PreSandbox is mainly for resource handling and not related to the GPU + // driver, it doesn't need the GPU watchdog. The loadLibrary may take long + // time that killing and restarting the GPU process will not help. +@@ -258,7 +258,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + } + + bool attempted_startsandbox = false; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) && !defined(OS_HAIKU) + // On Chrome OS ARM Mali, GPU driver userspace creates threads when + // initializing a GL context, so start the sandbox early. + // TODO(zmo): Need to collect OS version before this. +@@ -267,7 +267,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + watchdog_thread_.get(), &gpu_info_, gpu_preferences_); + attempted_startsandbox = true; + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) && !defined(OS_HAIKU) + + base::TimeTicks before_initialize_one_off = base::TimeTicks::Now(); + +@@ -291,14 +291,14 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + } + if (gl_initialized && use_swiftshader && + gl::GetGLImplementation() != gl::kGLImplementationSwiftShaderGL) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + VLOG(1) << "Quit GPU process launch to fallback to SwiftShader cleanly " + << "on Linux"; + return false; + #else + gl::init::ShutdownGL(true); + gl_initialized = false; +-#endif // OS_LINUX ++#endif // OS_LINUX || OS_HAIKU + } + + if (!gl_initialized) { +@@ -324,7 +324,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + } + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) && !defined(OS_HAIKU) + // The ContentSandboxHelper is currently the only one implementation of + // gpu::GpuSandboxHelper and it has no dependency. Except on Linux where + // VaapiWrapper checks the GL implementation to determine which display +@@ -375,7 +375,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + command_line, gpu_feature_info_, + gpu_preferences_.disable_software_rasterizer, false); + if (use_swiftshader) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + VLOG(1) << "Quit GPU process launch to fallback to SwiftShader cleanly " + << "on Linux"; + return false; +@@ -389,7 +389,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + << "failed"; + return false; + } +-#endif // OS_LINUX ++#endif // OS_LINUX || OS_HAIKU + } + } else { // use_swiftshader == true + switch (gpu_preferences_.use_vulkan) { +@@ -445,7 +445,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + + InitializePlatformOverlaySettings(&gpu_info_); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Driver may create a compatibility profile context when collect graphics + // information on Linux platform. Try to collect graphics information + // based on core profile context after disabling platform extensions. +@@ -464,7 +464,7 @@ bool GpuInit::InitializeAndStartSandbox(base::CommandLine* command_line, + return false; + } + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + if (use_swiftshader) { + AdjustInfoToSwiftShader(); +@@ -631,7 +631,7 @@ void GpuInit::InitializeInProcess(base::CommandLine* command_line, + + InitializePlatformOverlaySettings(&gpu_info_); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Driver may create a compatibility profile context when collect graphics + // information on Linux platform. Try to collect graphics information + // based on core profile context after disabling platform extensions. +@@ -651,7 +651,7 @@ void GpuInit::InitializeInProcess(base::CommandLine* command_line, + } + } + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + if (use_swiftshader) { + AdjustInfoToSwiftShader(); +diff --git a/src/3rdparty/chromium/gpu/ipc/service/gpu_memory_buffer_factory.cc b/src/3rdparty/chromium/gpu/ipc/service/gpu_memory_buffer_factory.cc +index edec577..cbe9bd2 100644 +--- a/src/3rdparty/chromium/gpu/ipc/service/gpu_memory_buffer_factory.cc ++++ b/src/3rdparty/chromium/gpu/ipc/service/gpu_memory_buffer_factory.cc +@@ -12,7 +12,7 @@ + #include "gpu/ipc/service/gpu_memory_buffer_factory_io_surface.h" + #endif + +-#if defined(OS_LINUX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + #include "gpu/ipc/service/gpu_memory_buffer_factory_native_pixmap.h" + #endif + +@@ -34,7 +34,7 @@ GpuMemoryBufferFactory::CreateNativeType( + return std::make_unique(); + #elif defined(OS_ANDROID) + return std::make_unique(); +-#elif defined(OS_LINUX) || defined(OS_FUCHSIA) ++#elif defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + return std::make_unique( + vulkan_context_provider); + #elif defined(OS_WIN) +diff --git a/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.cc b/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.cc +index cc5d8a9..a9a6dcd 100644 +--- a/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.cc ++++ b/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.cc +@@ -64,7 +64,7 @@ void GpuWatchdogTimeoutHistogram(GpuWatchdogTimeoutEvent timeout_event) { + base::UmaHistogramEnumeration("GPU.WatchdogThread.V1.Timeout", timeout_event); + } + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + const base::FilePath::CharType kTtyFilePath[] = + FILE_PATH_LITERAL("/sys/class/tty/tty0/active"); + #endif +@@ -82,7 +82,7 @@ GpuWatchdogThreadImplV1::GpuWatchdogThreadImplV1() + arm_cpu_time_(), + #endif + suspension_counter_(this) +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + , + host_tty_(-1) + #endif +@@ -104,7 +104,7 @@ GpuWatchdogThreadImplV1::GpuWatchdogThreadImplV1() + DCHECK(result); + #endif + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + tty_file_ = base::OpenFile(base::FilePath(kTtyFilePath), "r"); + UpdateActiveTTY(); + host_tty_ = active_tty_; +@@ -252,7 +252,7 @@ GpuWatchdogThreadImplV1::~GpuWatchdogThreadImplV1() { + + base::PowerMonitor::RemoveObserver(this); + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + if (tty_file_) + fclose(tty_file_); + #endif +@@ -435,7 +435,7 @@ void GpuWatchdogThreadImplV1::DeliberatelyTerminateToRecoverFromHang() { + return; + #endif + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + // Don't crash if we're not on the TTY of our host X11 server. + UpdateActiveTTY(); + if (host_tty_ != -1 && active_tty_ != -1 && host_tty_ != active_tty_) { +@@ -610,7 +610,7 @@ base::ThreadTicks GpuWatchdogThreadImplV1::GetWatchedThreadTime() { + } + #endif + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + void GpuWatchdogThreadImplV1::UpdateActiveTTY() { + last_active_tty_ = active_tty_; + +diff --git a/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.h b/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.h +index a2c633d..3864972 100644 +--- a/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.h ++++ b/src/3rdparty/chromium/gpu/ipc/service/gpu_watchdog_thread.h +@@ -213,7 +213,7 @@ class GPU_IPC_SERVICE_EXPORT GpuWatchdogThreadImplV1 + base::ThreadTicks GetWatchedThreadTime(); + #endif + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + void UpdateActiveTTY(); + #endif + +@@ -271,7 +271,7 @@ class GPU_IPC_SERVICE_EXPORT GpuWatchdogThreadImplV1 + // whether GpuWatchdogThreadEvent::kGpuWatchdogStart has been recorded. + bool is_watchdog_start_histogram_recorded = false; + +-#if defined(USE_X11) ++#if defined(USE_X11) && !defined(OS_HAIKU) + FILE* tty_file_; + int host_tty_; + int active_tty_ = -1; +diff --git a/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.cc b/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.cc +index 77c2a79..8d28412 100644 +--- a/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.cc ++++ b/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.cc +@@ -828,7 +828,7 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers( + } + #endif // defined(OS_ANDROID) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + if (gfx::HasExtension(enabled_extensions, + VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME)) { + vkGetSemaphoreFdKHRFn = reinterpret_cast( +@@ -847,9 +847,9 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers( + return false; + } + } +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + if (gfx::HasExtension(enabled_extensions, + VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME)) { + vkGetMemoryFdKHRFn = reinterpret_cast( +@@ -869,7 +869,7 @@ bool VulkanFunctionPointers::BindDeviceFunctionPointers( + return false; + } + } +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + + #if defined(OS_FUCHSIA) + if (gfx::HasExtension(enabled_extensions, +diff --git a/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.h b/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.h +index 290a7ea..5c5603a 100644 +--- a/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.h ++++ b/src/3rdparty/chromium/gpu/vulkan/vulkan_function_pointers.h +@@ -227,15 +227,15 @@ struct VulkanFunctionPointers { + vkGetAndroidHardwareBufferPropertiesANDROIDFn; + #endif // defined(OS_ANDROID) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + VulkanFunction vkGetSemaphoreFdKHRFn; + VulkanFunction vkImportSemaphoreFdKHRFn; +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + VulkanFunction vkGetMemoryFdKHRFn; + VulkanFunction vkGetMemoryFdPropertiesKHRFn; +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + + #if defined(OS_FUCHSIA) + VulkanFunction +@@ -447,18 +447,18 @@ struct VulkanFunctionPointers { + ->vkGetAndroidHardwareBufferPropertiesANDROIDFn + #endif // defined(OS_ANDROID) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + #define vkGetSemaphoreFdKHR \ + gpu::GetVulkanFunctionPointers()->vkGetSemaphoreFdKHRFn + #define vkImportSemaphoreFdKHR \ + gpu::GetVulkanFunctionPointers()->vkImportSemaphoreFdKHRFn +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + #define vkGetMemoryFdKHR gpu::GetVulkanFunctionPointers()->vkGetMemoryFdKHRFn + #define vkGetMemoryFdPropertiesKHR \ + gpu::GetVulkanFunctionPointers()->vkGetMemoryFdPropertiesKHRFn +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + + #if defined(OS_FUCHSIA) + #define vkImportSemaphoreZirconHandleFUCHSIA \ +@@ -493,4 +493,4 @@ struct VulkanFunctionPointers { + gpu::GetVulkanFunctionPointers()->vkGetSwapchainImagesKHRFn + #define vkQueuePresentKHR gpu::GetVulkanFunctionPointers()->vkQueuePresentKHRFn + +-#endif // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_ +\ No newline at end of file ++#endif // GPU_VULKAN_VULKAN_FUNCTION_POINTERS_H_ +diff --git a/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.cc b/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.cc +index 6e4d474..e21e9af 100644 +--- a/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.cc ++++ b/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.cc +@@ -157,7 +157,7 @@ HeadlessContentBrowserClient::GetGeneratedCodeCacheSettings( + return content::GeneratedCodeCacheSettings(true, 0, context->GetPath()); + } + +-#if defined(OS_POSIX) && !defined(OS_MACOSX) ++#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + void HeadlessContentBrowserClient::GetAdditionalMappedFilesForChildProcess( + const base::CommandLine& command_line, + int child_process_id, +@@ -168,7 +168,7 @@ void HeadlessContentBrowserClient::GetAdditionalMappedFilesForChildProcess( + mappings->Share(service_manager::kCrashDumpSignal, crash_signal_fd); + #endif // defined(HEADLESS_USE_BREAKPAD) + } +-#endif // defined(OS_POSIX) && !defined(OS_MACOSX) ++#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + + void HeadlessContentBrowserClient::AppendExtraCommandLineSwitches( + base::CommandLine* command_line, +@@ -231,7 +231,7 @@ void HeadlessContentBrowserClient::AppendExtraCommandLineSwitches( + process_type, child_process_id); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Processes may only query perf_event_open with the BPF sandbox disabled. + if (old_command_line.HasSwitch(::switches::kEnableThreadInstructionCount) && + old_command_line.HasSwitch(service_manager::switches::kNoSandbox)) { +diff --git a/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.h b/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.h +index 51576d2..e89bc08 100644 +--- a/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.h ++++ b/src/3rdparty/chromium/headless/lib/browser/headless_content_browser_client.h +@@ -29,7 +29,7 @@ class HeadlessContentBrowserClient : public content::ContentBrowserClient { + override; + content::GeneratedCodeCacheSettings GetGeneratedCodeCacheSettings( + content::BrowserContext* context) override; +-#if defined(OS_POSIX) && !defined(OS_MACOSX) ++#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + void GetAdditionalMappedFilesForChildProcess( + const base::CommandLine& command_line, + int child_process_id, +diff --git a/src/3rdparty/chromium/headless/lib/browser/headless_request_context_manager.cc b/src/3rdparty/chromium/headless/lib/browser/headless_request_context_manager.cc +index 100144c..6aea6c0 100644 +--- a/src/3rdparty/chromium/headless/lib/browser/headless_request_context_manager.cc ++++ b/src/3rdparty/chromium/headless/lib/browser/headless_request_context_manager.cc +@@ -27,7 +27,7 @@ namespace headless { + + namespace { + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + static char kProductName[] = "HeadlessChrome"; + #endif + +@@ -57,7 +57,7 @@ net::NetworkTrafficAnnotationTag GetProxyConfigTrafficAnnotationTag() { + return traffic_annotation; + } + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + ::network::mojom::CryptConfigPtr BuildCryptConfigOnce( + const base::FilePath& user_data_path) { + static bool done_once = false; +@@ -205,7 +205,7 @@ HeadlessRequestContextManager::HeadlessRequestContextManager( + proxy_config_monitor_ = std::make_unique( + base::ThreadTaskRunnerHandle::Get()); + } +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + auto crypt_config = BuildCryptConfigOnce(user_data_path_); + if (crypt_config) + content::GetNetworkService()->SetCryptConfig(std::move(crypt_config)); +diff --git a/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.cc b/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.cc +index 665ae63..67d2780 100644 +--- a/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.cc ++++ b/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.cc +@@ -322,7 +322,7 @@ void HeadlessContentMainDelegate::InitCrashReporter( + const base::CommandLine& command_line) { + if (command_line.HasSwitch(::switches::kDisableBreakpad)) + return; +-#if defined(OS_FUCHSIA) ++#if defined(OS_FUCHSIA) || defined(OS_HAIKU) + // TODO(fuchsia): Implement this when crash reporting/Breakpad are available + // in Fuchsia. (crbug.com/753619) + NOTIMPLEMENTED(); +@@ -351,7 +351,7 @@ void HeadlessContentMainDelegate::InitCrashReporter( + crash_reporter::InitializeCrashpadWithEmbeddedHandler( + process_type.empty(), process_type, "", base::FilePath()); + #endif // defined(HEADLESS_USE_BREAKPAD) +-#endif // defined(OS_FUCHSIA) ++#endif // defined(OS_FUCHSIA) || defined(OS_HAIKU) + } + + +@@ -405,7 +405,7 @@ int HeadlessContentMainDelegate::RunProcess( + } + #endif // !defined(CHROME_MULTIPLE_DLL_CHILD) + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + void SIGTERMProfilingShutdown(int signal) { + content::Profiling::Stop(); + struct sigaction sigact; +@@ -440,7 +440,7 @@ void HeadlessContentMainDelegate::ZygoteForked() { + breakpad::InitCrashReporter(process_type); + #endif + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + // static + HeadlessContentMainDelegate* HeadlessContentMainDelegate::GetInstance() { +diff --git a/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.h b/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.h +index 7d44327..f4effbf 100644 +--- a/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.h ++++ b/src/3rdparty/chromium/headless/lib/headless_content_main_delegate.h +@@ -60,7 +60,7 @@ class HEADLESS_EXPORT HeadlessContentMainDelegate + + HeadlessBrowserImpl* browser() const { return browser_.get(); } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + void ZygoteForked() override; + #endif + +diff --git a/src/3rdparty/chromium/headless/lib/headless_macros.h b/src/3rdparty/chromium/headless/lib/headless_macros.h +index f8d57ae..88773ee 100644 +--- a/src/3rdparty/chromium/headless/lib/headless_macros.h ++++ b/src/3rdparty/chromium/headless/lib/headless_macros.h +@@ -7,8 +7,8 @@ + + #include "build/build_config.h" + +-#if defined(OS_POSIX) && !defined(OS_MACOSX) ++#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + #define HEADLESS_USE_BREAKPAD +-#endif // defined(OS_POSIX) && !defined(OS_MACOSX) ++#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) + + #endif // HEADLESS_LIB_HEADLESS_MACROS_H_ +diff --git a/src/3rdparty/chromium/ipc/ipc_channel.h b/src/3rdparty/chromium/ipc/ipc_channel.h +index 7115461..9aeed64 100644 +--- a/src/3rdparty/chromium/ipc/ipc_channel.h ++++ b/src/3rdparty/chromium/ipc/ipc_channel.h +@@ -283,7 +283,7 @@ class COMPONENT_EXPORT(IPC) Channel : public Sender { + static std::string GenerateUniqueRandomChannelID(); + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Sandboxed processes live in a PID namespace, so when sending the IPC hello + // message from client to server we need to send the PID from the global + // PID namespace. +diff --git a/src/3rdparty/chromium/ipc/ipc_channel_common.cc b/src/3rdparty/chromium/ipc/ipc_channel_common.cc +index 3a14117..90a3ec3 100644 +--- a/src/3rdparty/chromium/ipc/ipc_channel_common.cc ++++ b/src/3rdparty/chromium/ipc/ipc_channel_common.cc +@@ -10,7 +10,7 @@ + + namespace IPC { + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + + namespace { + int g_global_pid = 0; +@@ -26,7 +26,7 @@ int Channel::GetGlobalPid() { + return g_global_pid; + } + +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + // static + std::unique_ptr Channel::CreateClient( +diff --git a/src/3rdparty/chromium/ipc/ipc_channel_mojo.cc b/src/3rdparty/chromium/ipc/ipc_channel_mojo.cc +index 02c955b..164622f 100644 +--- a/src/3rdparty/chromium/ipc/ipc_channel_mojo.cc ++++ b/src/3rdparty/chromium/ipc/ipc_channel_mojo.cc +@@ -74,7 +74,7 @@ class MojoChannelFactory : public ChannelFactory { + }; + + base::ProcessId GetSelfPID() { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (int global_pid = Channel::GetGlobalPid()) + return global_pid; + #endif // OS_LINUX +diff --git a/src/3rdparty/chromium/media/BUILD.gn b/src/3rdparty/chromium/media/BUILD.gn +index bb5842b..f83cdc4 100644 +--- a/src/3rdparty/chromium/media/BUILD.gn ++++ b/src/3rdparty/chromium/media/BUILD.gn +@@ -67,6 +67,9 @@ config("media_config") { + defines += [ "DLOPEN_PULSEAUDIO" ] + } + } ++ if (use_sndio) { ++ defines += [ "USE_SNDIO" ] ++ } + if (use_cras) { + defines += [ "USE_CRAS" ] + } +diff --git a/src/3rdparty/chromium/media/audio/alsa/audio_manager_alsa.cc b/src/3rdparty/chromium/media/audio/alsa/audio_manager_alsa.cc +index 3f0c60e..d12ec5c 100644 +--- a/src/3rdparty/chromium/media/audio/alsa/audio_manager_alsa.cc ++++ b/src/3rdparty/chromium/media/audio/alsa/audio_manager_alsa.cc +@@ -92,7 +92,9 @@ void AudioManagerAlsa::GetAlsaAudioDevices(StreamType type, + int card = -1; + + // Loop through the sound cards to get ALSA device hints. ++#ifdef OS_LINUX + while (!wrapper_->CardNext(&card) && card >= 0) { ++#endif + void** hints = NULL; + int error = wrapper_->DeviceNameHint(card, kPcmInterfaceName, &hints); + if (!error) { +@@ -104,7 +106,9 @@ void AudioManagerAlsa::GetAlsaAudioDevices(StreamType type, + DLOG(WARNING) << "GetAlsaAudioDevices: unable to get device hints: " + << wrapper_->StrError(error); + } ++#ifdef OS_LINUX + } ++#endif + } + + void AudioManagerAlsa::GetAlsaDevicesInfo(AudioManagerAlsa::StreamType type, +@@ -187,7 +191,11 @@ bool AudioManagerAlsa::IsAlsaDeviceAvailable( + // goes through software conversion if needed (e.g. incompatible + // sample rate). + // TODO(joi): Should we prefer "hw" instead? ++#ifdef OS_LINUX + static const char kDeviceTypeDesired[] = "plughw"; ++#else ++ static const char kDeviceTypeDesired[] = "plug"; ++#endif + return strncmp(kDeviceTypeDesired, device_name, + base::size(kDeviceTypeDesired) - 1) == 0; + } +@@ -209,7 +217,9 @@ bool AudioManagerAlsa::HasAnyAlsaAudioDevice( + // Loop through the sound cards. + // Don't use snd_device_name_hint(-1,..) since there is a access violation + // inside this ALSA API with libasound.so.2.0.0. ++#ifdef OS_LINUX + while (!wrapper_->CardNext(&card) && (card >= 0) && !has_device) { ++#endif + int error = wrapper_->DeviceNameHint(card, kPcmInterfaceName, &hints); + if (!error) { + for (void** hint_iter = hints; *hint_iter != NULL; hint_iter++) { +@@ -233,7 +243,9 @@ bool AudioManagerAlsa::HasAnyAlsaAudioDevice( + DLOG(WARNING) << "HasAnyAudioDevice: unable to get device hints: " + << wrapper_->StrError(error); + } ++#ifdef OS_LINUX + } ++#endif + + return has_device; + } +diff --git a/src/3rdparty/chromium/media/audio/audio_features.cc b/src/3rdparty/chromium/media/audio/audio_features.cc +index 394c40d..a6789ba 100644 +--- a/src/3rdparty/chromium/media/audio/audio_features.cc ++++ b/src/3rdparty/chromium/media/audio/audio_features.cc +@@ -11,7 +11,7 @@ namespace features { + // detected. It will be restarted when needed. + const base::Feature kAudioServiceOutOfProcessKillAtHang{ + "AudioServiceOutOfProcessKillAtHang", +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + base::FEATURE_ENABLED_BY_DEFAULT + #else + base::FEATURE_DISABLED_BY_DEFAULT +diff --git a/src/3rdparty/chromium/media/audio/audio_input_device.cc b/src/3rdparty/chromium/media/audio/audio_input_device.cc +index 2636701..fc21625 100644 +--- a/src/3rdparty/chromium/media/audio/audio_input_device.cc ++++ b/src/3rdparty/chromium/media/audio/audio_input_device.cc +@@ -248,7 +248,7 @@ void AudioInputDevice::OnStreamCreated( + // also a risk of false positives if we are suspending when starting the stream + // here. See comments in AliveChecker and PowerObserverHelper for details and + // todos. +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const bool stop_at_first_alive_notification = true; + const bool pause_check_during_suspend = false; + #else +diff --git a/src/3rdparty/chromium/media/audio/audio_manager.cc b/src/3rdparty/chromium/media/audio/audio_manager.cc +index f2a2e2d..1edee3c 100644 +--- a/src/3rdparty/chromium/media/audio/audio_manager.cc ++++ b/src/3rdparty/chromium/media/audio/audio_manager.cc +@@ -48,7 +48,7 @@ class AudioManagerHelper { + } + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + void set_app_name(const std::string& app_name) { app_name_ = app_name; } + const std::string& app_name() const { return app_name_; } + #endif +@@ -59,7 +59,7 @@ class AudioManagerHelper { + std::unique_ptr com_initializer_for_testing_; + #endif + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + std::string app_name_; + #endif + +@@ -130,7 +130,7 @@ std::unique_ptr AudioManager::CreateForTesting( + return Create(std::move(audio_thread), GetHelper()->fake_log_factory()); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // static + void AudioManager::SetGlobalAppName(const std::string& app_name) { + GetHelper()->set_app_name(app_name); +diff --git a/src/3rdparty/chromium/media/audio/audio_manager.h b/src/3rdparty/chromium/media/audio/audio_manager.h +index 4ffacd1..8e99458 100644 +--- a/src/3rdparty/chromium/media/audio/audio_manager.h ++++ b/src/3rdparty/chromium/media/audio/audio_manager.h +@@ -60,7 +60,7 @@ class MEDIA_EXPORT AudioManager { + static std::unique_ptr CreateForTesting( + std::unique_ptr audio_thread); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Sets the name of the audio source as seen by external apps. Only actually + // used with PulseAudio and MPRIS as of this writing. + static void SetGlobalAppName(const std::string& app_name); +diff --git a/src/3rdparty/chromium/media/audio/audio_output_proxy_unittest.cc b/src/3rdparty/chromium/media/audio/audio_output_proxy_unittest.cc +index 7e92fa3..fda041d 100644 +--- a/src/3rdparty/chromium/media/audio/audio_output_proxy_unittest.cc ++++ b/src/3rdparty/chromium/media/audio/audio_output_proxy_unittest.cc +@@ -412,7 +412,7 @@ class AudioOutputProxyTest : public testing::Test { + // |stream| is closed at this point. Start() should reopen it again. + EXPECT_CALL(manager(), MakeAudioOutputStream(_, _, _)) + .Times(2) +- .WillRepeatedly(Return(reinterpret_cast(NULL))); ++ .WillRepeatedly(Return(static_cast(NULL))); + + EXPECT_CALL(callback_, OnError(_)).Times(2); + +diff --git a/src/3rdparty/chromium/media/base/audio_latency.cc b/src/3rdparty/chromium/media/base/audio_latency.cc +index 887dea9..1e5c10e 100644 +--- a/src/3rdparty/chromium/media/base/audio_latency.cc ++++ b/src/3rdparty/chromium/media/base/audio_latency.cc +@@ -113,7 +113,7 @@ int AudioLatency::GetRtcBufferSize(int sample_rate, int hardware_buffer_size) { + return frames_per_buffer; + } + +-#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + // On Linux, MacOS and Fuchsia, the low level IO implementations on the + // browser side supports all buffer size the clients want. We use the native + // peer connection buffer size (10ms) to achieve best possible performance. +diff --git a/src/3rdparty/chromium/media/base/media_switches.cc b/src/3rdparty/chromium/media/base/media_switches.cc +index c623238..2386da7 100644 +--- a/src/3rdparty/chromium/media/base/media_switches.cc ++++ b/src/3rdparty/chromium/media/base/media_switches.cc +@@ -346,7 +346,7 @@ const base::Feature kGav1VideoDecoder{"Gav1VideoDecoder", + const base::Feature kGlobalMediaControls { + "GlobalMediaControls", + #if defined(OS_WIN) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + base::FEATURE_ENABLED_BY_DEFAULT + #else + base::FEATURE_DISABLED_BY_DEFAULT +diff --git a/src/3rdparty/chromium/media/base/status.cc b/src/3rdparty/chromium/media/base/status.cc +index 003b657..339688b 100644 +--- a/src/3rdparty/chromium/media/base/status.cc ++++ b/src/3rdparty/chromium/media/base/status.cc +@@ -66,7 +66,9 @@ Status&& Status::AddCause(Status&& cause) && { + + void Status::AddFrame(const base::Location& location) { + DCHECK(data_); ++#if SUPPORTS_LOCATION_BUILTINS + data_->frames.push_back(MediaSerialize(location)); ++#endif + } + + Status OkStatus() { +diff --git a/src/3rdparty/chromium/media/base/video_frame.cc b/src/3rdparty/chromium/media/base/video_frame.cc +index 0bb025a..a477952 100644 +--- a/src/3rdparty/chromium/media/base/video_frame.cc ++++ b/src/3rdparty/chromium/media/base/video_frame.cc +@@ -57,7 +57,7 @@ std::string VideoFrame::StorageTypeToString( + return "OWNED_MEMORY"; + case VideoFrame::STORAGE_SHMEM: + return "SHMEM"; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + case VideoFrame::STORAGE_DMABUFS: + return "DMABUFS"; + #endif +@@ -74,7 +74,7 @@ std::string VideoFrame::StorageTypeToString( + // static + bool VideoFrame::IsStorageTypeMappable(VideoFrame::StorageType storage_type) { + return +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // This is not strictly needed but makes explicit that, at VideoFrame + // level, DmaBufs are not mappable from userspace. + storage_type != VideoFrame::STORAGE_DMABUFS && +@@ -259,7 +259,7 @@ static base::Optional GetDefaultLayout( + return VideoFrameLayout::CreateWithPlanes(format, coded_size, planes); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // This class allows us to embed a vector into a scoped_refptr, and + // thus to have several VideoFrames share the same set of DMABUF FDs. + class VideoFrame::DmabufHolder +@@ -277,7 +277,7 @@ class VideoFrame::DmabufHolder + friend class base::RefCountedThreadSafe; + ~DmabufHolder() = default; + }; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + // static + bool VideoFrame::IsValidConfig(VideoPixelFormat format, +@@ -590,7 +590,7 @@ scoped_refptr VideoFrame::WrapExternalGpuMemoryBuffer( + return frame; + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // static + scoped_refptr VideoFrame::WrapExternalDmabufs( + const VideoFrameLayout& layout, +@@ -726,7 +726,7 @@ scoped_refptr VideoFrame::WrapVideoFrame( + } + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + DCHECK(frame->dmabuf_fds_); + // If there are any |dmabuf_fds_| plugged in, we should refer them too. + wrapping_frame->dmabuf_fds_ = frame->dmabuf_fds_; +@@ -1059,7 +1059,7 @@ VideoFrame::mailbox_holder(size_t texture_index) const { + : mailbox_holders_[texture_index]; + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const std::vector& VideoFrame::DmabufFds() const { + DCHECK_EQ(storage_type_, STORAGE_DMABUFS); + +@@ -1142,7 +1142,7 @@ VideoFrame::VideoFrame(const VideoFrameLayout& layout, + storage_type_(storage_type), + visible_rect_(Intersection(visible_rect, gfx::Rect(layout.coded_size()))), + natural_size_(natural_size), +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + dmabuf_fds_(base::MakeRefCounted()), + #endif + timestamp_(timestamp), +diff --git a/src/3rdparty/chromium/media/base/video_frame.h b/src/3rdparty/chromium/media/base/video_frame.h +index 6b1a5b4..f9c276a 100644 +--- a/src/3rdparty/chromium/media/base/video_frame.h ++++ b/src/3rdparty/chromium/media/base/video_frame.h +@@ -39,9 +39,9 @@ + #include "base/mac/scoped_cftyperef.h" + #endif // defined(OS_MACOSX) + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "base/files/scoped_file.h" +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + namespace gfx { + class GpuMemoryBuffer; +@@ -80,7 +80,7 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe { + STORAGE_UNOWNED_MEMORY = 2, // External, non owned data pointers. + STORAGE_OWNED_MEMORY = 3, // VideoFrame has allocated its own data buffer. + STORAGE_SHMEM = 4, // Backed by unsafe (writable) shared memory. +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // TODO(mcasas): Consider turning this type into STORAGE_NATIVE + // based on the idea of using this same enum value for both DMA + // buffers on Linux and CVPixelBuffers on Mac (which currently use +@@ -244,7 +244,7 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe { + ReleaseMailboxCB mailbox_holder_release_cb, + base::TimeDelta timestamp); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Wraps provided dmabufs + // (https://www.kernel.org/doc/html/latest/driver-api/dma-buf.html) with a + // VideoFrame. The frame will take ownership of |dmabuf_fds|, and will +@@ -476,7 +476,7 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe { + // mailbox, the caller must wait for the included sync point. + const gpu::MailboxHolder& mailbox_holder(size_t texture_index) const; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Returns a vector containing the backing DmaBufs for this frame. The number + // of returned DmaBufs will be equal or less than the number of planes of + // the frame. If there are less, this means that the last FD contains the +@@ -654,7 +654,7 @@ class MEDIA_EXPORT VideoFrame : public base::RefCountedThreadSafe { + // GPU memory buffer, if this frame is STORAGE_GPU_MEMORY_BUFFER. + std::unique_ptr gpu_memory_buffer_; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + class DmabufHolder; + + // Dmabufs for the frame, used when storage is STORAGE_DMABUFS. Size is either +diff --git a/src/3rdparty/chromium/media/blink/webmediaplayer_impl.cc b/src/3rdparty/chromium/media/blink/webmediaplayer_impl.cc +index bf58056..ab53b45 100644 +--- a/src/3rdparty/chromium/media/blink/webmediaplayer_impl.cc ++++ b/src/3rdparty/chromium/media/blink/webmediaplayer_impl.cc +@@ -280,7 +280,11 @@ void CreateAllocation(base::trace_event::ProcessMemoryDump* pmd, + + auto* std_allocator = base::trace_event::MemoryDumpManager::GetInstance() + ->system_allocator_pool_name(); +- pmd->AddSuballocation(dump->guid(), std_allocator); ++ if (std_allocator == nullptr) { ++ pmd->AddSuballocation(dump->guid(), std::string()); ++ } else { ++ pmd->AddSuballocation(dump->guid(), std_allocator); ++ } + } + + } // namespace +diff --git a/src/3rdparty/chromium/media/capture/video/linux/v4l2_capture_delegate.cc b/src/3rdparty/chromium/media/capture/video/linux/v4l2_capture_delegate.cc +index 279ae9b..aa14926 100644 +--- a/src/3rdparty/chromium/media/capture/video/linux/v4l2_capture_delegate.cc ++++ b/src/3rdparty/chromium/media/capture/video/linux/v4l2_capture_delegate.cc +@@ -4,8 +4,10 @@ + + #include "media/capture/video/linux/v4l2_capture_delegate.h" + ++#if !defined(OS_HAIKU) + #include + #include ++#endif + #include + #include + #include +@@ -13,7 +15,7 @@ + + #include + +-#if !defined(OS_OPENBSD) ++#if !defined(OS_HAIKU) + #include + #endif + +@@ -28,10 +30,10 @@ + + using media::mojom::MeteringMode; + +-#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0) ++// #if LINUX_VERSION_CODE < KERNEL_VERSION(4, 6, 0) + // 16 bit depth, Realsense F200. + #define V4L2_PIX_FMT_Z16 v4l2_fourcc('Z', '1', '6', ' ') +-#endif ++// #endif + + // TODO(aleksandar.stojiljkovic): Wrap this with kernel version check once the + // format is introduced to kernel. +@@ -341,9 +343,9 @@ void V4L2CaptureDelegate::AllocateAndStart( + // operation (|errno| == EINVAL in this case) or plain failure. + if ((power_line_frequency_ == V4L2_CID_POWER_LINE_FREQUENCY_50HZ) + || (power_line_frequency_ == V4L2_CID_POWER_LINE_FREQUENCY_60HZ) +-#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0) ++//#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0) + || (power_line_frequency_ == V4L2_CID_POWER_LINE_FREQUENCY_AUTO) +-#endif ++//#endif + ) { + struct v4l2_control control = {}; + control.id = V4L2_CID_POWER_LINE_FREQUENCY; +diff --git a/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc b/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc +index aab89030..35c712e 100644 +--- a/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc ++++ b/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_factory_linux.cc +@@ -315,6 +315,7 @@ void VideoCaptureDeviceFactoryLinux::GetSupportedFormatsForV4L2BufferType( + supported_format.pixel_format = + VideoCaptureDeviceLinux::V4l2FourCcToChromiumPixelFormat( + v4l2_format.pixelformat); ++ supported_format.pixel_format = PIXEL_FORMAT_UNKNOWN; + + if (supported_format.pixel_format == PIXEL_FORMAT_UNKNOWN) + continue; +diff --git a/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_linux.cc b/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_linux.cc +index 3eac2c6..1ebfbff 100644 +--- a/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_linux.cc ++++ b/src/3rdparty/chromium/media/capture/video/linux/video_capture_device_linux.cc +@@ -17,8 +17,10 @@ + #include + #else + #include ++#if !defined(OS_HAIKU) + #include + #endif ++#endif + + namespace media { + +@@ -31,12 +33,12 @@ int TranslatePowerLineFrequencyToV4L2(PowerLineFrequency frequency) { + case PowerLineFrequency::FREQUENCY_60HZ: + return V4L2_CID_POWER_LINE_FREQUENCY_60HZ; + default: +-#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0) ++//#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0) + // If we have no idea of the frequency, at least try and set it to AUTO. + return V4L2_CID_POWER_LINE_FREQUENCY_AUTO; +-#else +- return V4L2_CID_POWER_LINE_FREQUENCY_60HZ; +-#endif ++//#else ++// return V4L2_CID_POWER_LINE_FREQUENCY_60HZ; ++//#endif + } + } + +diff --git a/src/3rdparty/chromium/media/capture/video/video_capture_buffer_pool_impl.cc b/src/3rdparty/chromium/media/capture/video/video_capture_buffer_pool_impl.cc +index 4a260cc..71f9457 100644 +--- a/src/3rdparty/chromium/media/capture/video/video_capture_buffer_pool_impl.cc ++++ b/src/3rdparty/chromium/media/capture/video/video_capture_buffer_pool_impl.cc +@@ -58,7 +58,7 @@ VideoCaptureBufferPoolImpl::CreateSharedMemoryViaRawFileDescriptorStruct( + int buffer_id) { + // This requires platforms where base::SharedMemoryHandle is backed by a + // file descriptor. +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + base::AutoLock lock(lock_); + + VideoCaptureBufferTracker* tracker = GetTracker(buffer_id); +diff --git a/src/3rdparty/chromium/media/capture/video/video_capture_device_client.cc b/src/3rdparty/chromium/media/capture/video/video_capture_device_client.cc +index 618be0e..86be5f9 100644 +--- a/src/3rdparty/chromium/media/capture/video/video_capture_device_client.cc ++++ b/src/3rdparty/chromium/media/capture/video/video_capture_device_client.cc +@@ -301,7 +301,7 @@ void VideoCaptureDeviceClient::OnIncomingCapturedData( + // see http://linuxtv.org/downloads/v4l-dvb-apis/packed-rgb.html. + // Windows RGB24 defines blue at lowest byte, + // see https://msdn.microsoft.com/en-us/library/windows/desktop/dd407253 +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + fourcc_format = libyuv::FOURCC_RAW; + #elif defined(OS_WIN) + fourcc_format = libyuv::FOURCC_24BG; +diff --git a/src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc b/src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc +index aa4ea57..4ac0a2c 100644 +--- a/src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc ++++ b/src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc +@@ -767,10 +767,6 @@ ChannelLayout ChannelLayoutToChromeChannelLayout(int64_t layout, int channels) { + } + } + +-#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. +diff --git a/src/3rdparty/chromium/media/filters/vp9_parser.h b/src/3rdparty/chromium/media/filters/vp9_parser.h +index 4f36038..6de6951 100644 +--- a/src/3rdparty/chromium/media/filters/vp9_parser.h ++++ b/src/3rdparty/chromium/media/filters/vp9_parser.h +@@ -14,6 +14,7 @@ + + #include + #include ++#include + #include + + #include +diff --git a/src/3rdparty/chromium/media/formats/common/offset_byte_queue.cc b/src/3rdparty/chromium/media/formats/common/offset_byte_queue.cc +index b355e1a..6fa7a9b 100644 +--- a/src/3rdparty/chromium/media/formats/common/offset_byte_queue.cc ++++ b/src/3rdparty/chromium/media/formats/common/offset_byte_queue.cc +@@ -46,13 +46,13 @@ void OffsetByteQueue::PeekAt(int64_t offset, const uint8_t** buf, int* size) { + *size = tail() - offset; + } + +-bool OffsetByteQueue::Trim(int64_t max_offset) { +- if (max_offset < head_) return true; +- if (max_offset > tail()) { ++bool OffsetByteQueue::Trim(int64_t _max_offset) { ++ if (_max_offset < head_) return true; ++ if (_max_offset > tail()) { + Pop(size_); + return false; + } +- Pop(max_offset - head_); ++ Pop(_max_offset - head_); + return true; + } + +diff --git a/src/3rdparty/chromium/media/formats/common/offset_byte_queue.h b/src/3rdparty/chromium/media/formats/common/offset_byte_queue.h +index eb0bd2c..95effd7 100644 +--- a/src/3rdparty/chromium/media/formats/common/offset_byte_queue.h ++++ b/src/3rdparty/chromium/media/formats/common/offset_byte_queue.h +@@ -36,15 +36,15 @@ class MEDIA_EXPORT OffsetByteQueue { + // a null |buf| and a |size| of zero. + void PeekAt(int64_t offset, const uint8_t** buf, int* size); + +- // Marks the bytes up to (but not including) |max_offset| as ready for ++ // Marks the bytes up to (but not including) |_max_offset| as ready for + // deletion. This is relatively inexpensive, but will not necessarily reduce + // the resident buffer size right away (or ever). + // + // Returns true if the full range of bytes were successfully trimmed, +- // including the case where |max_offset| is less than the current head. +- // Returns false if |max_offset| > tail() (although all bytes currently ++ // including the case where |_max_offset| is less than the current head. ++ // Returns false if |_max_offset| > tail() (although all bytes currently + // buffered are still cleared). +- bool Trim(int64_t max_offset); ++ bool Trim(int64_t _max_offset); + + // The head and tail positions, in terms of the file's absolute offsets. + // tail() is an exclusive bound. +diff --git a/src/3rdparty/chromium/media/formats/mp2t/es_parser_adts.cc b/src/3rdparty/chromium/media/formats/mp2t/es_parser_adts.cc +index c612e6e..58be02b 100644 +--- a/src/3rdparty/chromium/media/formats/mp2t/es_parser_adts.cc ++++ b/src/3rdparty/chromium/media/formats/mp2t/es_parser_adts.cc +@@ -62,11 +62,11 @@ bool EsParserAdts::LookForAdtsFrame(AdtsFrame* adts_frame) { + const uint8_t* es; + es_queue_->Peek(&es, &es_size); + +- int max_offset = es_size - kADTSHeaderMinSize; +- if (max_offset <= 0) ++ int _max_offset = es_size - kADTSHeaderMinSize; ++ if (_max_offset <= 0) + return false; + +- for (int offset = 0; offset < max_offset; offset++) { ++ for (int offset = 0; offset < _max_offset; offset++) { + const uint8_t* cur_buf = &es[offset]; + if (!isAdtsSyncWord(cur_buf)) + continue; +@@ -106,7 +106,7 @@ bool EsParserAdts::LookForAdtsFrame(AdtsFrame* adts_frame) { + return true; + } + +- es_queue_->Pop(max_offset); ++ es_queue_->Pop(_max_offset); + return false; + } + +diff --git a/src/3rdparty/chromium/media/formats/mp2t/es_parser_mpeg1audio.cc b/src/3rdparty/chromium/media/formats/mp2t/es_parser_mpeg1audio.cc +index 0a4cb15..9db3c31 100644 +--- a/src/3rdparty/chromium/media/formats/mp2t/es_parser_mpeg1audio.cc ++++ b/src/3rdparty/chromium/media/formats/mp2t/es_parser_mpeg1audio.cc +@@ -108,11 +108,11 @@ bool EsParserMpeg1Audio::LookForMpeg1AudioFrame( + const uint8_t* es; + es_queue_->Peek(&es, &es_size); + +- int max_offset = es_size - MPEG1AudioStreamParser::kHeaderSize; +- if (max_offset <= 0) ++ int _max_offset = es_size - MPEG1AudioStreamParser::kHeaderSize; ++ if (_max_offset <= 0) + return false; + +- for (int offset = 0; offset < max_offset; offset++) { ++ for (int offset = 0; offset < _max_offset; offset++) { + const uint8_t* cur_buf = &es[offset]; + if (cur_buf[0] != 0xff) + continue; +@@ -153,7 +153,7 @@ bool EsParserMpeg1Audio::LookForMpeg1AudioFrame( + return true; + } + +- es_queue_->Pop(max_offset); ++ es_queue_->Pop(_max_offset); + return false; + } + +diff --git a/src/3rdparty/chromium/media/formats/mp4/box_definitions.cc b/src/3rdparty/chromium/media/formats/mp4/box_definitions.cc +index 8206c5a..9616e12 100644 +--- a/src/3rdparty/chromium/media/formats/mp4/box_definitions.cc ++++ b/src/3rdparty/chromium/media/formats/mp4/box_definitions.cc +@@ -1224,15 +1224,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]; + +diff --git a/src/3rdparty/chromium/media/gpu/buffer_validation.cc b/src/3rdparty/chromium/media/gpu/buffer_validation.cc +index ad27864..f2aab1a 100644 +--- a/src/3rdparty/chromium/media/gpu/buffer_validation.cc ++++ b/src/3rdparty/chromium/media/gpu/buffer_validation.cc +@@ -12,15 +12,15 @@ + #include "ui/gfx/geometry/size.h" + #include "ui/gfx/gpu_memory_buffer.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include + #include +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + namespace media { + + bool GetFileSize(const int fd, size_t* size) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (fd < 0) { + VLOGF(1) << "Invalid file descriptor"; + return false; +@@ -46,7 +46,7 @@ bool GetFileSize(const int fd, size_t* size) { + #else + NOTIMPLEMENTED(); + return false; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + } + + bool VerifyGpuMemoryBufferHandle(media::VideoPixelFormat pixel_format, +@@ -56,7 +56,7 @@ bool VerifyGpuMemoryBufferHandle(media::VideoPixelFormat pixel_format, + VLOGF(1) << "Unexpected GpuMemoryBufferType: " << gmb_handle.type; + return false; + } +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + const size_t num_planes = media::VideoFrame::NumPlanes(pixel_format); + if (num_planes != gmb_handle.native_pixmap_handle.planes.size() || + num_planes == 0) { +@@ -108,7 +108,7 @@ bool VerifyGpuMemoryBufferHandle(media::VideoPixelFormat pixel_format, + #else + NOTIMPLEMENTED(); + return false; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + } + + } // namespace media +diff --git a/src/3rdparty/chromium/media/media_options.gni b/src/3rdparty/chromium/media/media_options.gni +index 011bd47..e06e8f7 100644 +--- a/src/3rdparty/chromium/media/media_options.gni ++++ b/src/3rdparty/chromium/media/media_options.gni +@@ -123,6 +123,9 @@ declare_args() { + # Enables runtime selection of ALSA library for audio. + use_alsa = false + ++ # Enables runtime selection of sndio library for audio. ++ use_sndio = false ++ + # Alsa should be used on non-Android, non-Mac POSIX systems. + # Alsa should be used on desktop Chromecast and audio-only Chromecast builds. + if (is_posix && !is_android && !is_mac && +diff --git a/src/3rdparty/chromium/media/mojo/clients/mojo_video_encode_accelerator.cc b/src/3rdparty/chromium/media/mojo/clients/mojo_video_encode_accelerator.cc +index 627108c..d49407e 100644 +--- a/src/3rdparty/chromium/media/mojo/clients/mojo_video_encode_accelerator.cc ++++ b/src/3rdparty/chromium/media/mojo/clients/mojo_video_encode_accelerator.cc +@@ -132,7 +132,7 @@ void MojoVideoEncodeAccelerator::Encode(scoped_refptr frame, + DCHECK_EQ(num_planes, frame->layout().num_planes()); + DCHECK(vea_.is_bound()); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // TODO(crbug.com/1003197): Remove this once we stop supporting STORAGE_DMABUF + // in VideoEncodeAccelerator. + if (frame->storage_type() == VideoFrame::STORAGE_DMABUFS) { +diff --git a/src/3rdparty/chromium/media/mojo/mojom/video_frame_mojom_traits.cc b/src/3rdparty/chromium/media/mojo/mojom/video_frame_mojom_traits.cc +index 464be5d..e5b9b0d 100644 +--- a/src/3rdparty/chromium/media/mojo/mojom/video_frame_mojom_traits.cc ++++ b/src/3rdparty/chromium/media/mojo/mojom/video_frame_mojom_traits.cc +@@ -20,9 +20,9 @@ + #include "ui/gfx/mojom/buffer_types_mojom_traits.h" + #include "ui/gfx/mojom/color_space_mojom_traits.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "base/posix/eintr_wrapper.h" +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + namespace mojo { + +@@ -62,7 +62,7 @@ media::mojom::VideoFrameDataPtr MakeVideoFrameData( + std::move(offsets))); + } + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + if (input->storage_type() == media::VideoFrame::STORAGE_DMABUFS) { + std::vector dmabuf_fds; + +@@ -165,7 +165,7 @@ bool StructTraits gpu_task_runner, + base::WeakPtr media_gpu_channel_manager, +@@ -279,7 +279,7 @@ std::unique_ptr GpuMojoMediaClient::CreateVideoDecoder( + command_buffer_id->route_id)); + } + +-#elif defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX) ++#elif defined(OS_MACOSX) || defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + #if defined(OS_WIN) + // Don't instantiate the DXVA decoder if it's not supported. + if (gpu_workarounds_.disable_dxva_video_decoder) +diff --git a/src/3rdparty/chromium/media/video/fake_gpu_memory_buffer.cc b/src/3rdparty/chromium/media/video/fake_gpu_memory_buffer.cc +index 586f1f8..06eb802 100644 +--- a/src/3rdparty/chromium/media/video/fake_gpu_memory_buffer.cc ++++ b/src/3rdparty/chromium/media/video/fake_gpu_memory_buffer.cc +@@ -6,7 +6,7 @@ + + #include "build/build_config.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include + #include + #include +@@ -44,7 +44,7 @@ class FakeGpuMemoryBufferImpl : public gpu::GpuMemoryBufferImpl { + + } // namespace + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + base::ScopedFD GetDummyFD() { + base::ScopedFD fd(open("/dev/zero", O_RDWR)); + DCHECK(fd.is_valid()); +@@ -67,7 +67,7 @@ FakeGpuMemoryBuffer::FakeGpuMemoryBuffer(const gfx::Size& size, + // Set a dummy id since this is for testing only. + handle_.id = gfx::GpuMemoryBufferId(0); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Set a dummy fd since this is for testing only. + handle_.native_pixmap_handle.planes.push_back( + gfx::NativePixmapPlane(size_.width(), 0, y_plane_size, GetDummyFD())); +@@ -76,7 +76,7 @@ FakeGpuMemoryBuffer::FakeGpuMemoryBuffer(const gfx::Size& size, + size_.width(), handle_.native_pixmap_handle.planes[0].size, + uv_plane_size, GetDummyFD())); + } +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + } + + FakeGpuMemoryBuffer::~FakeGpuMemoryBuffer() = default; +@@ -135,7 +135,7 @@ gfx::GpuMemoryBufferHandle FakeGpuMemoryBuffer::CloneHandle() const { + gfx::GpuMemoryBufferHandle handle; + handle.type = gfx::NATIVE_PIXMAP; + handle.id = handle_.id; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + handle.native_pixmap_handle = + gfx::CloneHandleForIPC(handle_.native_pixmap_handle); + #endif +diff --git a/src/3rdparty/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc b/src/3rdparty/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc +index cd549e5..9301330 100644 +--- a/src/3rdparty/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc ++++ b/src/3rdparty/chromium/media/video/gpu_memory_buffer_video_frame_pool.cc +@@ -572,7 +572,7 @@ void GpuMemoryBufferVideoFramePool::PoolImpl::CreateHardwareFrame( + } + + bool is_software_backed_video_frame = !video_frame->HasTextures(); +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + is_software_backed_video_frame &= !video_frame->HasDmaBufs(); + #endif + +diff --git a/src/3rdparty/chromium/media/webrtc/webrtc_switches.cc b/src/3rdparty/chromium/media/webrtc/webrtc_switches.cc +index 481e16a..f5b37ca 100644 +--- a/src/3rdparty/chromium/media/webrtc/webrtc_switches.cc ++++ b/src/3rdparty/chromium/media/webrtc/webrtc_switches.cc +@@ -50,7 +50,7 @@ namespace media { + + bool IsWebRtcApmInAudioServiceEnabled() { + #if defined(OS_WIN) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + return base::FeatureList::IsEnabled(features::kWebRtcApmInAudioService) && + !base::CommandLine::ForCurrentProcess()->HasSwitch( + switches::kForceDisableWebRtcApmInAudioService); +diff --git a/src/3rdparty/chromium/mojo/public/c/system/thunks.cc b/src/3rdparty/chromium/mojo/public/c/system/thunks.cc +index 1bf1a26..e90e278 100644 +--- a/src/3rdparty/chromium/mojo/public/c/system/thunks.cc ++++ b/src/3rdparty/chromium/mojo/public/c/system/thunks.cc +@@ -15,7 +15,7 @@ + #include "build/build_config.h" + #include "mojo/public/c/system/core.h" + +-#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) ++#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + #include "base/environment.h" + #include "base/files/file_path.h" + #include "base/optional.h" +@@ -58,7 +58,7 @@ namespace mojo { + class CoreLibraryInitializer { + public: + CoreLibraryInitializer(const MojoInitializeOptions* options) { +-#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) ++#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + bool application_provided_path = false; + base::Optional library_path; + if (options && options->struct_size >= sizeof(*options) && +@@ -77,7 +77,7 @@ class CoreLibraryInitializer { + + if (!library_path) { + // Default to looking for the library in the current working directory. +-#if defined(OS_CHROMEOS) || defined(OS_LINUX) ++#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_HAIKU) + const base::FilePath::CharType kDefaultLibraryPathValue[] = + FILE_PATH_LITERAL("./libmojo_core.so"); + #elif defined(OS_WIN) +@@ -127,16 +127,16 @@ class CoreLibraryInitializer { + + CHECK_GT(g_thunks.size, 0u) + << "Invalid mojo_core library: " << library_path->value(); +-#else // defined(OS_CHROMEOS) || defined(OS_LINUX) ++#else // defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_HAIKU) + NOTREACHED() + << "Dynamic mojo_core loading is not supported on this platform."; +-#endif // defined(OS_CHROMEOS) || defined(OS_LINUX) ++#endif // defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_HAIKU) + } + + ~CoreLibraryInitializer() = default; + + private: +-#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) ++#if defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + base::Optional library_; + #endif + +diff --git a/src/3rdparty/chromium/mojo/public/js/mojo_bindings_resources.grd b/src/3rdparty/chromium/mojo/public/js/mojo_bindings_resources.grd +index 83da5be..ea614bd 100644 +--- a/src/3rdparty/chromium/mojo/public/js/mojo_bindings_resources.grd ++++ b/src/3rdparty/chromium/mojo/public/js/mojo_bindings_resources.grd +@@ -70,7 +70,7 @@ + use_base_dir="false" + type="BINDATA" + compress="gzip" /> +- ++ + ++#else ++#include ++#endif + + #include + #include +diff --git a/src/3rdparty/chromium/net/base/network_change_notifier.cc b/src/3rdparty/chromium/net/base/network_change_notifier.cc +index ac1b3e0..1c3dda5 100644 +--- a/src/3rdparty/chromium/net/base/network_change_notifier.cc ++++ b/src/3rdparty/chromium/net/base/network_change_notifier.cc +@@ -35,7 +35,7 @@ + #include "net/base/network_change_notifier_linux.h" + #elif defined(OS_MACOSX) + #include "net/base/network_change_notifier_mac.h" +-#elif defined(OS_CHROMEOS) || defined(OS_ANDROID) ++#elif defined(OS_CHROMEOS) || defined(OS_ANDROID) || defined(OS_HAIKU) + #include "net/base/network_change_notifier_posix.h" + #elif defined(OS_FUCHSIA) + #include "net/base/network_change_notifier_fuchsia.h" +@@ -240,8 +240,11 @@ std::unique_ptr NetworkChangeNotifier::CreateIfNeeded( + #elif defined(OS_FUCHSIA) + return std::make_unique( + 0 /* required_features */); ++#elif defined(OS_HAIKU) ++ return std::make_unique( ++ std::make_unique( ++ nullptr /* task_runner */, nullptr /* dns_config_service */)); + #else +- NOTIMPLEMENTED(); + return NULL; + #endif + } +diff --git a/src/3rdparty/chromium/net/base/network_interfaces_posix.h b/src/3rdparty/chromium/net/base/network_interfaces_posix.h +index 9a2bc40..116e077 100644 +--- a/src/3rdparty/chromium/net/base/network_interfaces_posix.h ++++ b/src/3rdparty/chromium/net/base/network_interfaces_posix.h +@@ -8,6 +8,8 @@ + // This file provides some basic functionality shared between + // network_interfaces_linux.cc and network_interfaces_getifaddrs.cc. + ++#include ++ + #include + + struct sockaddr; +diff --git a/src/3rdparty/chromium/net/cert/crl_set.cc b/src/3rdparty/chromium/net/cert/crl_set.cc +index 882c039..fbeba07 100644 +--- a/src/3rdparty/chromium/net/cert/crl_set.cc ++++ b/src/3rdparty/chromium/net/cert/crl_set.cc +@@ -8,6 +8,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" +@@ -57,9 +58,9 @@ base::DictionaryValue* ReadHeader(base::StringPiece* data) { + 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; +@@ -92,9 +93,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; +@@ -205,15 +206,6 @@ CRLSet::~CRLSet() = default; + // static + bool CRLSet::Parse(base::StringPiece data, scoped_refptr* 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 header_dict(ReadHeader(&data)); + if (!header_dict.get()) +diff --git a/src/3rdparty/chromium/net/dns/address_sorter_posix.cc b/src/3rdparty/chromium/net/dns/address_sorter_posix.cc +index b768391..aa09452 100644 +--- a/src/3rdparty/chromium/net/dns/address_sorter_posix.cc ++++ b/src/3rdparty/chromium/net/dns/address_sorter_posix.cc +@@ -14,6 +14,7 @@ + #include + #include + #include ++#include + #include + #include + #endif +diff --git a/src/3rdparty/chromium/net/dns/dns_config_service_posix_unittest.cc b/src/3rdparty/chromium/net/dns/dns_config_service_posix_unittest.cc +index 8989240..9190f71 100644 +--- a/src/3rdparty/chromium/net/dns/dns_config_service_posix_unittest.cc ++++ b/src/3rdparty/chromium/net/dns/dns_config_service_posix_unittest.cc +@@ -2,8 +2,6 @@ + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include +- + #include + + #include "base/cancelable_callback.h" +diff --git a/src/3rdparty/chromium/net/dns/dns_reloader.cc b/src/3rdparty/chromium/net/dns/dns_reloader.cc +index 1c014a6..83a39ed 100644 +--- a/src/3rdparty/chromium/net/dns/dns_reloader.cc ++++ b/src/3rdparty/chromium/net/dns/dns_reloader.cc +@@ -7,6 +7,10 @@ + #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \ + !defined(OS_ANDROID) && !defined(OS_FUCHSIA) + ++#if defined(OS_FREEBSD) ++#include ++#endif ++ + #include + + #include "base/lazy_instance.h" +diff --git a/src/3rdparty/chromium/net/dns/dns_util.cc b/src/3rdparty/chromium/net/dns/dns_util.cc +index 49bfdfc..4931074 100644 +--- a/src/3rdparty/chromium/net/dns/dns_util.cc ++++ b/src/3rdparty/chromium/net/dns/dns_util.cc +@@ -39,6 +39,8 @@ const uint16_t kFlagNamePointer = 0xc000; + + } // namespace + ++#include ++ + #if defined(OS_POSIX) + #include + #if !defined(OS_NACL) +diff --git a/src/3rdparty/chromium/net/dns/host_resolver_proc.cc b/src/3rdparty/chromium/net/dns/host_resolver_proc.cc +index 7fe8e1d..4fa6733 100644 +--- a/src/3rdparty/chromium/net/dns/host_resolver_proc.cc ++++ b/src/3rdparty/chromium/net/dns/host_resolver_proc.cc +@@ -159,7 +159,7 @@ int SystemHostResolverCall(const std::string& host, + base::ScopedBlockingCall scoped_blocking_call(FROM_HERE, + base::BlockingType::WILL_BLOCK); + +-#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \ ++#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_HAIKU) && \ + !defined(OS_ANDROID) && !defined(OS_FUCHSIA) + DnsReloaderMaybeReload(); + #endif +diff --git a/src/3rdparty/chromium/net/features.gni b/src/3rdparty/chromium/net/features.gni +index 33b03ba..c0fddfb 100644 +--- a/src/3rdparty/chromium/net/features.gni ++++ b/src/3rdparty/chromium/net/features.gni +@@ -23,7 +23,7 @@ declare_args() { + disable_brotli_filter = false + + # Multicast DNS. +- enable_mdns = is_win || is_linux || is_fuchsia || is_mac || is_ios ++ enable_mdns = is_win || is_linux || is_fuchsia || is_mac || is_ios || is_haiku + + # Reporting not used on iOS. + enable_reporting = !is_ios +diff --git a/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.cc b/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.cc +index 1b12032..c0d670b 100644 +--- a/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.cc ++++ b/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.cc +@@ -367,8 +367,9 @@ base::NativeLibrary GSSAPISharedLibrary::LoadSharedLibrary( + static const char* const kDefaultLibraryNames[] = { + #if defined(OS_MACOSX) + "/System/Library/Frameworks/GSS.framework/GSS" +-#elif defined(OS_OPENBSD) +- "libgssapi.so" // Heimdal - OpenBSD ++#elif defined(OS_HAIKU) ++ "libgssapi.so" // Heimdal - OpenBSD / FreeBSD ++ "libgssapi_krb5.so.2", // MIT Kerberos - FreeBSD + #else + "libgssapi_krb5.so.2", // MIT Kerberos - FC, Suse10, Debian + "libgssapi.so.4", // Heimdal - Suse10, MDK +diff --git a/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.h b/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.h +index 6340b62..0aba030 100644 +--- a/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.h ++++ b/src/3rdparty/chromium/net/http/http_auth_gssapi_posix.h +@@ -21,6 +21,9 @@ + #include + #elif defined(OS_FREEBSD) + #include ++#ifndef GSS_C_DELEG_POLICY_FLAG ++#define GSS_C_DELEG_POLICY_FLAG 32768 ++#endif + #else + #include + #endif +diff --git a/src/3rdparty/chromium/net/nqe/network_quality_estimator.cc b/src/3rdparty/chromium/net/nqe/network_quality_estimator.cc +index 33ebff9..4e7a0c0 100644 +--- a/src/3rdparty/chromium/net/nqe/network_quality_estimator.cc ++++ b/src/3rdparty/chromium/net/nqe/network_quality_estimator.cc +@@ -104,7 +104,7 @@ nqe::internal::NetworkID DoGetCurrentNetworkID( + case NetworkChangeNotifier::ConnectionType::CONNECTION_ETHERNET: + break; + case NetworkChangeNotifier::ConnectionType::CONNECTION_WIFI: +-#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_WIN) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + network_id.id = GetWifiSSID(); + #endif + break; +diff --git a/src/3rdparty/chromium/net/proxy_resolution/configured_proxy_resolution_service.cc b/src/3rdparty/chromium/net/proxy_resolution/configured_proxy_resolution_service.cc +index 1aefd62..6ad5474 100644 +--- a/src/3rdparty/chromium/net/proxy_resolution/configured_proxy_resolution_service.cc ++++ b/src/3rdparty/chromium/net/proxy_resolution/configured_proxy_resolution_service.cc +@@ -47,7 +47,7 @@ + #elif defined(OS_MACOSX) + #include "net/proxy_resolution/proxy_config_service_mac.h" + #include "net/proxy_resolution/proxy_resolver_mac.h" +-#elif defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#elif (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + #include "net/proxy_resolution/proxy_config_service_linux.h" + #elif defined(OS_ANDROID) + #include "net/proxy_resolution/proxy_config_service_android.h" +@@ -61,7 +61,7 @@ namespace net { + namespace { + + #if defined(OS_WIN) || defined(OS_IOS) || defined(OS_MACOSX) || \ +- (defined(OS_LINUX) && !defined(OS_CHROMEOS)) ++ (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + constexpr net::NetworkTrafficAnnotationTag kSystemProxyConfigTrafficAnnotation = + net::DefineNetworkTrafficAnnotation("proxy_config_system", R"( + semantics { +@@ -1436,7 +1436,7 @@ ConfiguredProxyResolutionService::CreateSystemProxyConfigService( + << "profile_io_data.cc::CreateProxyConfigService and this should " + << "be used only for examples."; + return std::make_unique(); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + std::unique_ptr linux_config_service( + new ProxyConfigServiceLinux()); + +diff --git a/src/3rdparty/chromium/net/socket/socket_posix.cc b/src/3rdparty/chromium/net/socket/socket_posix.cc +index 61cc758..7506f9e 100644 +--- a/src/3rdparty/chromium/net/socket/socket_posix.cc ++++ b/src/3rdparty/chromium/net/socket/socket_posix.cc +@@ -517,7 +517,7 @@ void SocketPosix::ReadCompleted() { + } + + int SocketPosix::DoWrite(IOBuffer* buf, int buf_len) { +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + // Disable SIGPIPE for this write. Although Chromium globally disables + // SIGPIPE, the net stack may be used in other consumers which do not do + // this. MSG_NOSIGNAL is a Linux-only API. On OS X, this is a setsockopt on +diff --git a/src/3rdparty/chromium/net/socket/socks5_client_socket.cc b/src/3rdparty/chromium/net/socket/socks5_client_socket.cc +index e22ddb2..4119ed5 100644 +--- a/src/3rdparty/chromium/net/socket/socks5_client_socket.cc ++++ b/src/3rdparty/chromium/net/socket/socks5_client_socket.cc +@@ -4,6 +4,10 @@ + + #include "net/socket/socks5_client_socket.h" + ++#if defined(OS_HAIKU) ++#include ++#endif ++ + #include + + #include "base/bind.h" +diff --git a/src/3rdparty/chromium/net/socket/unix_domain_client_socket_posix.cc b/src/3rdparty/chromium/net/socket/unix_domain_client_socket_posix.cc +index d0e4b3c..7f04bf9 100644 +--- a/src/3rdparty/chromium/net/socket/unix_domain_client_socket_posix.cc ++++ b/src/3rdparty/chromium/net/socket/unix_domain_client_socket_posix.cc +@@ -56,7 +56,7 @@ bool UnixDomainClientSocket::FillAddress(const std::string& socket_path, + return true; + } + +-#if defined(OS_ANDROID) || defined(OS_LINUX) ++#if defined(OS_ANDROID) || defined(OS_LINUX) || defined(OS_HAIKU) + // Convert the path given into abstract socket name. It must start with + // the '\0' character, so we are adding it. |addr_len| must specify the + // length of the structure exactly, as potentially the socket name may +diff --git a/src/3rdparty/chromium/net/tools/quic/quic_http_proxy_backend.cc b/src/3rdparty/chromium/net/tools/quic/quic_http_proxy_backend.cc +index 3223e6f..afabf12 100644 +--- a/src/3rdparty/chromium/net/tools/quic/quic_http_proxy_backend.cc ++++ b/src/3rdparty/chromium/net/tools/quic/quic_http_proxy_backend.cc +@@ -162,7 +162,7 @@ void QuicHttpProxyBackend::InitializeURLRequestContext() { + // Enable HTTP2, but disable QUIC on the backend + context_builder.SetSpdyAndQuicEnabled(true /* http2 */, false /* quic */); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // On Linux, use a fixed ProxyConfigService, since the default one + // depends on glib. + context_builder.set_proxy_config_service( +diff --git a/src/3rdparty/chromium/net/traffic_annotation/network_traffic_annotation.h b/src/3rdparty/chromium/net/traffic_annotation/network_traffic_annotation.h +index 6319a81..8419df4 100644 +--- a/src/3rdparty/chromium/net/traffic_annotation/network_traffic_annotation.h ++++ b/src/3rdparty/chromium/net/traffic_annotation/network_traffic_annotation.h +@@ -356,7 +356,7 @@ struct MutablePartialNetworkTrafficAnnotationTag { + } // namespace net + + // Placeholder for unannotated usages. +-#if !defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if !defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(OS_HAIKU) + #define TRAFFIC_ANNOTATION_WITHOUT_PROTO(ANNOTATION_ID) \ + net::DefineNetworkTrafficAnnotation(ANNOTATION_ID, "No proto yet.") + #endif +@@ -367,7 +367,7 @@ struct MutablePartialNetworkTrafficAnnotationTag { + // + // On Linux and Windows, use MISSING_TRAFFIC_ANNOTATION or + // TRAFFIC_ANNOTATION_FOR_TESTS. +-#if (!defined(OS_WIN) && !defined(OS_LINUX)) || defined(OS_CHROMEOS) ++#if (!defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(OS_CHROMEOS) + #define NO_TRAFFIC_ANNOTATION_YET \ + net::DefineNetworkTrafficAnnotation("undefined", "Nothing here yet.") + +diff --git a/src/3rdparty/chromium/net/url_request/url_fetcher.cc b/src/3rdparty/chromium/net/url_request/url_fetcher.cc +index 331420f..73f884b 100644 +--- a/src/3rdparty/chromium/net/url_request/url_fetcher.cc ++++ b/src/3rdparty/chromium/net/url_request/url_fetcher.cc +@@ -11,7 +11,7 @@ namespace net { + + URLFetcher::~URLFetcher() = default; + +-#if (!defined(OS_WIN) && !defined(OS_LINUX)) || defined(OS_CHROMEOS) ++#if (!defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(OS_CHROMEOS) + // static + std::unique_ptr URLFetcher::Create( + const GURL& url, +diff --git a/src/3rdparty/chromium/net/url_request/url_fetcher.h b/src/3rdparty/chromium/net/url_request/url_fetcher.h +index 98887b7..ae64b12 100644 +--- a/src/3rdparty/chromium/net/url_request/url_fetcher.h ++++ b/src/3rdparty/chromium/net/url_request/url_fetcher.h +@@ -114,7 +114,7 @@ class NET_EXPORT URLFetcher { + // The unannotated Create() methods are not available on desktop Linux + + // Windows. They are available on other platforms, since we only audit network + // annotations on Linux & Windows. +-#if (!defined(OS_WIN) && !defined(OS_LINUX)) || defined(OS_CHROMEOS) ++#if (!defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(OS_CHROMEOS) + // |url| is the URL to send the request to. It must be valid. + // |request_type| is the type of request to make. + // |d| the object that will receive the callback on fetch completion. +diff --git a/src/3rdparty/chromium/net/url_request/url_request_context.cc b/src/3rdparty/chromium/net/url_request/url_request_context.cc +index 9a13359..8788e14 100644 +--- a/src/3rdparty/chromium/net/url_request/url_request_context.cc ++++ b/src/3rdparty/chromium/net/url_request/url_request_context.cc +@@ -89,7 +89,7 @@ const HttpNetworkSession::Context* URLRequestContext::GetNetworkSessionContext() + return &network_session->context(); + } + +-#if (!defined(OS_WIN) && !defined(OS_LINUX)) || defined(OS_CHROMEOS) ++#if (!defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(OS_CHROMEOS) + std::unique_ptr URLRequestContext::CreateRequest( + const GURL& url, + RequestPriority priority, +diff --git a/src/3rdparty/chromium/net/url_request/url_request_context.h b/src/3rdparty/chromium/net/url_request/url_request_context.h +index f2bfa71..429110e 100644 +--- a/src/3rdparty/chromium/net/url_request/url_request_context.h ++++ b/src/3rdparty/chromium/net/url_request/url_request_context.h +@@ -82,7 +82,7 @@ class NET_EXPORT URLRequestContext + // session. + const HttpNetworkSession::Context* GetNetworkSessionContext() const; + +-#if (!defined(OS_WIN) && !defined(OS_LINUX)) || defined(OS_CHROMEOS) ++#if (!defined(OS_WIN) && !defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(OS_CHROMEOS) + // This function should not be used in Chromium, please use the version with + // NetworkTrafficAnnotationTag in the future. + // +diff --git a/src/3rdparty/chromium/net/url_request/url_request_context_builder.cc b/src/3rdparty/chromium/net/url_request/url_request_context_builder.cc +index 2e255cb..e74d40d 100644 +--- a/src/3rdparty/chromium/net/url_request/url_request_context_builder.cc ++++ b/src/3rdparty/chromium/net/url_request/url_request_context_builder.cc +@@ -485,7 +485,7 @@ std::unique_ptr URLRequestContextBuilder::Build() { + } + + if (!proxy_resolution_service_) { +-#if !defined(OS_LINUX) && !defined(OS_ANDROID) ++#if !defined(OS_LINUX) && !defined(OS_ANDROID) && !defined(OS_HAIKU) + // TODO(willchan): Switch to using this code when + // ConfiguredProxyResolutionService::CreateSystemProxyConfigService()'s + // signature doesn't suck. +@@ -494,7 +494,7 @@ std::unique_ptr URLRequestContextBuilder::Build() { + ConfiguredProxyResolutionService::CreateSystemProxyConfigService( + base::ThreadTaskRunnerHandle::Get().get()); + } +-#endif // !defined(OS_LINUX) && !defined(OS_ANDROID) ++#endif // !defined(OS_LINUX) && !defined(OS_ANDROID) && !defined(OS_HAIKU) + proxy_resolution_service_ = CreateProxyResolutionService( + std::move(proxy_config_service_), context.get(), + context->host_resolver(), context->network_delegate(), +diff --git a/src/3rdparty/chromium/pdf/pdfium/pdfium_engine.cc b/src/3rdparty/chromium/pdf/pdfium/pdfium_engine.cc +index 77b6c12..a0b117a 100644 +--- a/src/3rdparty/chromium/pdf/pdfium/pdfium_engine.cc ++++ b/src/3rdparty/chromium/pdf/pdfium/pdfium_engine.cc +@@ -52,7 +52,7 @@ + #include "ui/gfx/geometry/rect.h" + #include "v8/include/v8.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "pdf/pdfium/pdfium_font_linux.h" + #endif + +@@ -361,7 +361,7 @@ void InitializeSDK(bool enable_v8) { + config.m_v8EmbedderSlot = gin::kEmbedderPDFium; + FPDF_InitLibraryWithConfig(&config); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + InitializeLinuxFontMapper(); + #endif + +@@ -402,7 +402,7 @@ PDFiumEngine::PDFiumEngine(PDFEngine::Client* client, bool enable_javascript) + IFSDK_PAUSE::user = nullptr; + IFSDK_PAUSE::NeedToPauseNow = Pause_NeedToPauseNow; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // PreviewModeClient does not know its pp::Instance. + SetLastInstance(client_->GetPluginInstance()); + #endif +@@ -864,7 +864,7 @@ pp::Buffer_Dev PDFiumEngine::PrintPagesAsRasterPdf( + + KillFormFocus(); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + SetLastInstance(client_->GetPluginInstance()); + #endif + +@@ -2853,7 +2853,7 @@ bool PDFiumEngine::ContinuePaint(int progressive_index, + DCHECK(image_data); + + last_progressive_start_time_ = base::Time::Now(); +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + SetLastInstance(client_->GetPluginInstance()); + #endif + +@@ -3349,7 +3349,7 @@ void PDFiumEngine::SetCurrentPage(int index) { + FORM_DoPageAAction(old_page, form(), FPDFPAGE_AACTION_CLOSE); + } + most_visible_page_ = index; +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + SetLastInstance(client_->GetPluginInstance()); + #endif + if (most_visible_page_ != -1 && called_do_document_action_) { +diff --git a/src/3rdparty/chromium/ppapi/proxy/file_io_resource.cc b/src/3rdparty/chromium/ppapi/proxy/file_io_resource.cc +index 17c7b7c..1d84c50 100644 +--- a/src/3rdparty/chromium/ppapi/proxy/file_io_resource.cc ++++ b/src/3rdparty/chromium/ppapi/proxy/file_io_resource.cc +@@ -284,17 +284,17 @@ int32_t FileIOResource::Write(int64_t offset, + + if (check_quota_) { + int64_t increase = 0; +- uint64_t max_offset = 0; ++ uint64_t _max_offset = 0; + bool append = (open_flags_ & PP_FILEOPENFLAG_APPEND) != 0; + if (append) { + increase = bytes_to_write; + } else { +- uint64_t max_offset = offset + bytes_to_write; +- if (max_offset > ++ uint64_t _max_offset = offset + bytes_to_write; ++ if (_max_offset > + static_cast(std::numeric_limits::max())) { + return PP_ERROR_FAILED; // amount calculation would overflow. + } +- increase = static_cast(max_offset) - max_written_offset_; ++ increase = static_cast(_max_offset) - max_written_offset_; + } + + if (increase > 0) { +@@ -318,7 +318,7 @@ int32_t FileIOResource::Write(int64_t offset, + if (append) + append_mode_write_amount_ += bytes_to_write; + else +- max_written_offset_ = max_offset; ++ max_written_offset_ = _max_offset; + } + } + return WriteValidated(offset, buffer, bytes_to_write, callback); +@@ -594,9 +594,9 @@ void FileIOResource::OnRequestWriteQuotaComplete( + } else { + DCHECK_LE(offset + bytes_to_write - max_written_offset_, granted); + +- int64_t max_offset = offset + bytes_to_write; +- if (max_written_offset_ < max_offset) +- max_written_offset_ = max_offset; ++ int64_t _max_offset = offset + bytes_to_write; ++ if (max_written_offset_ < _max_offset) ++ max_written_offset_ = _max_offset; + } + + if (callback->is_blocking()) { +diff --git a/src/3rdparty/chromium/ppapi/proxy/flash_resource.cc b/src/3rdparty/chromium/ppapi/proxy/flash_resource.cc +index aafcb12..8f54cab 100644 +--- a/src/3rdparty/chromium/ppapi/proxy/flash_resource.cc ++++ b/src/3rdparty/chromium/ppapi/proxy/flash_resource.cc +@@ -136,7 +136,7 @@ double FlashResource::GetLocalTimeZoneOffset(PP_Instance instance, + // require filesystem access prohibited by the sandbox. + // TODO(shess): Figure out why OSX needs the access, the sandbox warmup should + // handle it. http://crbug.com/149006 +-#if defined(OS_LINUX) || defined(OS_MACOSX) ++#if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_HAIKU) + int32_t result = SyncCall( + BROWSER, + PpapiHostMsg_Flash_GetLocalTimeZoneOffset(PPTimeToTime(t)), +diff --git a/src/3rdparty/chromium/printing/cups_config_helper.py b/src/3rdparty/chromium/printing/cups_config_helper.py +index 373c244..6bc7289 100755 +--- a/src/3rdparty/chromium/printing/cups_config_helper.py ++++ b/src/3rdparty/chromium/printing/cups_config_helper.py +@@ -67,7 +67,7 @@ def main(): + mode = sys.argv[1] + if len(sys.argv) > 2 and sys.argv[2]: + sysroot = sys.argv[2] +- cups_config = os.path.join(sysroot, 'usr', 'bin', 'cups-config') ++ cups_config = os.path.join(sysroot, 'bin', 'cups-config') + if not os.path.exists(cups_config): + print('cups-config not found: %s' % cups_config) + return 1 +diff --git a/src/3rdparty/chromium/sandbox/linux/services/init_process_reaper.cc b/src/3rdparty/chromium/sandbox/linux/services/init_process_reaper.cc +index 112fa0a..5409ffc 100644 +--- a/src/3rdparty/chromium/sandbox/linux/services/init_process_reaper.cc ++++ b/src/3rdparty/chromium/sandbox/linux/services/init_process_reaper.cc +@@ -1,6 +1,7 @@ + // Copyright 2013 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. ++#if 0 + + #include "sandbox/linux/services/init_process_reaper.h" + +@@ -100,3 +101,4 @@ bool CreateInitProcessReaper(base::OnceClosure post_fork_parent_callback) { + } + + } // namespace sandbox. ++#endif +diff --git a/src/3rdparty/chromium/services/device/serial/BUILD.gn b/src/3rdparty/chromium/services/device/serial/BUILD.gn +index d75328b..63bbe34 100644 +--- a/src/3rdparty/chromium/services/device/serial/BUILD.gn ++++ b/src/3rdparty/chromium/services/device/serial/BUILD.gn +@@ -4,7 +4,7 @@ + + import("//build/config/features.gni") + +-if (is_win || (is_linux && use_udev) || is_mac) { ++if (is_win || (is_linux && use_udev) || is_mac || is_haiku) { + config("platform_support") { + visibility = [ ":serial" ] + if (is_win) { +diff --git a/src/3rdparty/chromium/services/device/serial/serial_io_handler_posix.cc b/src/3rdparty/chromium/services/device/serial/serial_io_handler_posix.cc +index 7f2a2c4..23eeb86 100644 +--- a/src/3rdparty/chromium/services/device/serial/serial_io_handler_posix.cc ++++ b/src/3rdparty/chromium/services/device/serial/serial_io_handler_posix.cc +@@ -66,7 +66,7 @@ bool BitrateToSpeedConstant(int bitrate, speed_t* speed) { + BITRATE_TO_SPEED_CASE(9600) + BITRATE_TO_SPEED_CASE(19200) + BITRATE_TO_SPEED_CASE(38400) +-#if !defined(OS_MACOSX) ++#if !defined(OS_MACOSX) && !defined(OS_HAIKU) + BITRATE_TO_SPEED_CASE(57600) + BITRATE_TO_SPEED_CASE(115200) + BITRATE_TO_SPEED_CASE(230400) +diff --git a/src/3rdparty/chromium/services/device/time_zone_monitor/time_zone_monitor_linux.cc b/src/3rdparty/chromium/services/device/time_zone_monitor/time_zone_monitor_linux.cc +index 65ca480..4ecef88 100644 +--- a/src/3rdparty/chromium/services/device/time_zone_monitor/time_zone_monitor_linux.cc ++++ b/src/3rdparty/chromium/services/device/time_zone_monitor/time_zone_monitor_linux.cc +@@ -127,7 +127,11 @@ class TimeZoneMonitorLinuxImpl + // false positives are harmless, assuming the false positive rate is + // reasonable. + const char* const kFilesToWatch[] = { ++#if defined(OS_HAIKU) ++ "/etc/localtime", ++#else + "/etc/localtime", "/etc/timezone", "/etc/TZ", ++#endif + }; + for (size_t index = 0; index < base::size(kFilesToWatch); ++index) { + file_path_watchers_.push_back(std::make_unique()); +diff --git a/src/3rdparty/chromium/services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.cc b/src/3rdparty/chromium/services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.cc +index 632e8da..ba3a281 100644 +--- a/src/3rdparty/chromium/services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.cc ++++ b/src/3rdparty/chromium/services/resource_coordinator/memory_instrumentation/queued_request_dispatcher.cc +@@ -43,7 +43,7 @@ namespace { + uint32_t CalculatePrivateFootprintKb(const mojom::RawOSMemDump& os_dump, + uint32_t shared_resident_kb) { + DCHECK(os_dump.platform_private_footprint); +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + uint64_t rss_anon_bytes = os_dump.platform_private_footprint->rss_anon_bytes; + uint64_t vm_swap_bytes = os_dump.platform_private_footprint->vm_swap_bytes; + return (rss_anon_bytes + vm_swap_bytes) / 1024; +@@ -82,7 +82,7 @@ memory_instrumentation::mojom::OSMemDumpPtr CreatePublicOSDump( + os_dump->is_peak_rss_resettable = internal_os_dump.is_peak_rss_resettable; + os_dump->private_footprint_kb = + CalculatePrivateFootprintKb(internal_os_dump, shared_resident_kb); +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + os_dump->private_footprint_swap_kb = + internal_os_dump.platform_private_footprint->vm_swap_bytes / 1024; + #endif +diff --git a/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h b/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h +index 58944b0..580cc58 100644 +--- a/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h ++++ b/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h +@@ -28,9 +28,9 @@ class COMPONENT_EXPORT( + mojom::RawOSMemDump*); + static std::vector GetProcessMemoryMaps(base::ProcessId); + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + static void SetProcSmapsForTesting(FILE*); +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + + private: + FRIEND_TEST_ALL_PREFIXES(OSMetricsTest, ParseProcSmaps); +@@ -44,7 +44,7 @@ class COMPONENT_EXPORT( + static std::vector GetProcessModules(base::ProcessId); + #endif + +-#if defined(OS_LINUX) || defined(OS_ANDROID) ++#if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + // Provides information on the dump state of resident pages. + enum class MappedAndResidentPagesDumpState { + // Access to /proc//pagemap can be denied for android devices running +@@ -68,7 +68,7 @@ class COMPONENT_EXPORT( + // TODO(chiniforooshan): move to /base/process/process_metrics_linux.cc after + // making sure that peak RSS is useful. + static size_t GetPeakResidentSetSize(base::ProcessId pid); +-#endif // defined(OS_LINUX) || defined(OS_ANDROID) ++#endif // defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_HAIKU) + }; + + } // namespace memory_instrumentation +diff --git a/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics_linux.cc b/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics_linux.cc +index fb0cfd2..e47bfca 100644 +--- a/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics_linux.cc ++++ b/src/3rdparty/chromium/services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics_linux.cc +@@ -24,8 +24,10 @@ + #include "build/build_config.h" + #include "services/resource_coordinator/public/cpp/memory_instrumentation/os_metrics.h" + ++#if !defined(OS_HAIKU) + // Symbol with virtual address of the start of ELF header of the current binary. + extern char __ehdr_start; ++#endif + + namespace memory_instrumentation { + +@@ -88,6 +90,7 @@ struct ModuleData { + + ModuleData GetMainModuleData() { + ModuleData module_data; ++#if !defined(OS_HAIKU) + Dl_info dl_info; + if (dladdr(&__ehdr_start, &dl_info)) { + base::debug::ElfBuildIdBuffer build_id; +@@ -98,6 +101,7 @@ ModuleData GetMainModuleData() { + module_data.build_id = std::string(build_id, build_id_length); + } + } ++#endif + return module_data; + } + +@@ -145,14 +149,14 @@ bool ParseSmapsHeader(const char* header_line, + // Build ID is needed to symbolize heap profiles, and is generated only on + // official builds. Build ID is only added for the current library (chrome) + // since it is racy to read other libraries which can be unmapped any time. +-#if defined(OFFICIAL_BUILD) ++#if defined(OFFICIAL_BUILD) && !defined(OS_HAIKU) + if (!region->mapped_file.empty() && + base::StartsWith(main_module_data.path, region->mapped_file, + base::CompareCase::SENSITIVE) && + !main_module_data.build_id.empty()) { + region->module_debugid = main_module_data.build_id; + } +-#endif // defined(OFFICIAL_BUILD) ++#endif // defined(OFFICIAL_BUILD) && !defined(OS_HAIKU) + + return res; + } +@@ -241,6 +245,7 @@ bool OSMetrics::FillOSMemoryDump(base::ProcessId pid, + mojom::RawOSMemDump* dump) { + // TODO(chiniforooshan): There is no need to read both /statm and /status + // files. Refactor to get everything from /status using ProcessMetric. ++#if !defined(OS_HAIKU) + auto statm_file = GetProcPidDir(pid).Append("statm"); + auto autoclose = base::ScopedFD(open(statm_file.value().c_str(), O_RDONLY)); + int statm_fd = autoclose.get(); +@@ -255,6 +260,10 @@ bool OSMetrics::FillOSMemoryDump(base::ProcessId pid, + + if (!success) + return false; ++#else ++ uint64_t resident_pages = 0; ++ uint64_t shared_pages = 0; ++#endif + + auto process_metrics = CreateProcessMetrics(pid); + +@@ -295,6 +304,10 @@ bool OSMetrics::FillOSMemoryDump(base::ProcessId pid, + + // static + std::vector OSMetrics::GetProcessMemoryMaps(base::ProcessId pid) { ++#if defined(OS_HAIKU) ++ NOTIMPLEMENTED(); ++ return std::vector(); ++#else + std::vector maps; + uint32_t res = 0; + if (g_proc_smaps_for_testing) { +@@ -312,6 +325,7 @@ std::vector OSMetrics::GetProcessMemoryMaps(base::ProcessId pid) { + return std::vector(); + + return maps; ++#endif + } + + // static +@@ -319,6 +333,10 @@ OSMetrics::MappedAndResidentPagesDumpState OSMetrics::GetMappedAndResidentPages( + const size_t start_address, + const size_t end_address, + std::vector* accessed_pages_bitmap) { ++#if defined(OS_HAIKU) ++ NOTIMPLEMENTED(); ++ return OSMetrics::MappedAndResidentPagesDumpState::kFailure; ++#else + const char* kPagemap = "/proc/self/pagemap"; + + base::ScopedFILE pagemap_file(fopen(kPagemap, "r")); +@@ -360,6 +378,7 @@ OSMetrics::MappedAndResidentPagesDumpState OSMetrics::GetMappedAndResidentPages( + } + } + return OSMetrics::MappedAndResidentPagesDumpState::kSuccess; ++#endif + } + + // static +diff --git a/src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc b/src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc +index a85c0ea..00bcd12 100644 +--- a/src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc ++++ b/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 ++#endif ++ + // TODO(vignatti): replace the local definitions below with #include + // once kernel version 4.6 becomes widely used. + #include +diff --git a/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.cc b/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.cc +index 90e2e0b..ede1a86 100644 +--- a/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.cc ++++ b/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.cc +@@ -72,6 +72,7 @@ ZygoteHostImpl* ZygoteHostImpl::GetInstance() { + } + + void ZygoteHostImpl::Init(const base::CommandLine& command_line) { ++#if !defined(OS_HAIKU) + if (command_line.HasSwitch(service_manager::switches::kNoSandbox)) { + return; + } +@@ -122,6 +123,7 @@ void ZygoteHostImpl::Init(const base::CommandLine& command_line) { + "you can try using --" + << service_manager::switches::kNoSandbox << "."; + } ++#endif + } + + void ZygoteHostImpl::AddZygotePid(pid_t pid) { +@@ -146,6 +148,7 @@ pid_t ZygoteHostImpl::LaunchZygote( + base::CommandLine* cmd_line, + base::ScopedFD* control_fd, + base::FileHandleMappingVector additional_remapped_fds) { ++#if !defined(OS_HAIKU) + int fds[2]; + CHECK_EQ(0, socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds)); + CHECK(base::UnixDomainSocket::EnableReceiveProcessId(fds[0])); +@@ -213,9 +216,12 @@ pid_t ZygoteHostImpl::LaunchZygote( + + AddZygotePid(pid); + return pid; ++#else ++ return 0; ++#endif + } + +-#if !defined(OS_OPENBSD) ++#if !defined(OS_HAIKU) + void ZygoteHostImpl::AdjustRendererOOMScore(base::ProcessHandle pid, + int score) { + // 1) You can't change the oom_score_adj of a non-dumpable process +diff --git a/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.h b/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.h +index 64d6c45..827cce9 100644 +--- a/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.h ++++ b/src/3rdparty/chromium/services/service_manager/zygote/host/zygote_host_impl_linux.h +@@ -44,8 +44,10 @@ class COMPONENT_EXPORT(SERVICE_MANAGER_ZYGOTE) ZygoteHostImpl + base::ScopedFD* control_fd, + base::FileHandleMappingVector additional_remapped_fds); + ++#if !defined(OS_HAIKU) + void AdjustRendererOOMScore(base::ProcessHandle process_handle, + int score) override; ++#endif + bool HasZygote() { return !zygote_pids_.empty(); } + + private: +diff --git a/src/3rdparty/chromium/services/service_manager/zygote/zygote_host_linux.h b/src/3rdparty/chromium/services/service_manager/zygote/zygote_host_linux.h +index 8e6416d..e10f33c 100644 +--- a/src/3rdparty/chromium/services/service_manager/zygote/zygote_host_linux.h ++++ b/src/3rdparty/chromium/services/service_manager/zygote/zygote_host_linux.h +@@ -30,11 +30,13 @@ class ZygoteHost { + // after the first render has been forked. + virtual int GetRendererSandboxStatus() const = 0; + ++#if !defined(OS_HAIKU) + // Adjust the OOM score of the given renderer's PID. The allowed + // range for the score is [0, 1000], where higher values are more + // likely to be killed by the OOM killer. + virtual void AdjustRendererOOMScore(base::ProcessHandle process_handle, + int score) = 0; ++#endif + }; + + } // namespace service_manager +diff --git a/src/3rdparty/chromium/services/service_manager/zygote/zygote_linux.cc b/src/3rdparty/chromium/services/service_manager/zygote/zygote_linux.cc +index aa601ab..0134b0c 100644 +--- a/src/3rdparty/chromium/services/service_manager/zygote/zygote_linux.cc ++++ b/src/3rdparty/chromium/services/service_manager/zygote/zygote_linux.cc +@@ -1,6 +1,7 @@ + // Copyright (c) 2012 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. ++#if 0 + + #include "services/service_manager/zygote/zygote_linux.h" + +@@ -657,3 +658,4 @@ bool Zygote::HandleGetSandboxStatus(int fd, base::PickleIterator iter) { + } + + } // namespace service_manager ++#endif +diff --git a/src/3rdparty/chromium/services/service_manager/zygote/zygote_main_linux.cc b/src/3rdparty/chromium/services/service_manager/zygote/zygote_main_linux.cc +index ed024a0..75bc3ae 100644 +--- a/src/3rdparty/chromium/services/service_manager/zygote/zygote_main_linux.cc ++++ b/src/3rdparty/chromium/services/service_manager/zygote/zygote_main_linux.cc +@@ -11,7 +11,9 @@ + #include + #include + #include ++#if !defined(OS_HAIKU) + #include ++#endif + #include + #include + #include +@@ -99,6 +101,7 @@ static bool CreateInitProcessReaper( + // created through the setuid sandbox. + static bool EnterSuidSandbox(sandbox::SetuidSandboxClient* setuid_sandbox, + base::OnceClosure post_fork_parent_callback) { ++#if !defined(OS_HAIKU) + DCHECK(setuid_sandbox); + DCHECK(setuid_sandbox->IsSuidSandboxChild()); + +@@ -131,6 +134,9 @@ static bool EnterSuidSandbox(sandbox::SetuidSandboxClient* setuid_sandbox, + + CHECK(service_manager::SandboxDebugHandling::SetDumpableStatusAndHandlers()); + return true; ++#else ++ return false; ++#endif + } + + static void DropAllCapabilities(int proc_fd) { +@@ -178,6 +184,7 @@ static void EnterLayerOneSandbox(service_manager::SandboxLinux* linux_sandbox, + + bool ZygoteMain( + std::vector> fork_delegates) { ++#if !defined(OS_HAIKU) + sandbox::SetAmZygoteOrRenderer(true, GetSandboxFD()); + + auto* linux_sandbox = service_manager::SandboxLinux::GetInstance(); +@@ -243,6 +250,9 @@ bool ZygoteMain( + + // This function call can return multiple times, once per fork(). + return zygote.ProcessRequests(); ++#else ++ return false; ++#endif + } + + } // namespace service_manager +diff --git a/src/3rdparty/chromium/services/video_capture/broadcasting_receiver.cc b/src/3rdparty/chromium/services/video_capture/broadcasting_receiver.cc +index 9b6bd3a..faf01ee 100644 +--- a/src/3rdparty/chromium/services/video_capture/broadcasting_receiver.cc ++++ b/src/3rdparty/chromium/services/video_capture/broadcasting_receiver.cc +@@ -39,7 +39,7 @@ void CloneSharedBufferHandle(const mojo::ScopedSharedBufferHandle& source, + void CloneSharedBufferToRawFileDescriptorHandle( + const mojo::ScopedSharedBufferHandle& source, + media::mojom::VideoBufferHandlePtr* target) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // |source| is unwrapped to a |PlatformSharedMemoryRegion|, from whence a file + // descriptor can be extracted which is then mojo-wrapped. + base::subtle::PlatformSharedMemoryRegion platform_region = +@@ -182,7 +182,7 @@ void BroadcastingReceiver::BufferContext:: + ConvertRawFileDescriptorToSharedBuffer() { + DCHECK(buffer_handle_->is_shared_memory_via_raw_file_descriptor()); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // The conversion unwraps the descriptor from its mojo handle to the raw file + // descriptor (ie, an int). This is used to create a + // PlatformSharedMemoryRegion which is then wrapped as a +diff --git a/src/3rdparty/chromium/skia/config/SkUserConfig.h b/src/3rdparty/chromium/skia/config/SkUserConfig.h +index 061d014..2534a20 100644 +--- a/src/3rdparty/chromium/skia/config/SkUserConfig.h ++++ b/src/3rdparty/chromium/skia/config/SkUserConfig.h +@@ -152,11 +152,18 @@ SK_API void SkDebugf_FileLine(const char* file, + ...); + + #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) + +@@ -170,17 +177,6 @@ SK_API void SkDebugf_FileLine(const char* file, + // 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 + + // These flags are no longer defined in Skia, but we have them (temporarily) +diff --git a/src/3rdparty/chromium/skia/ext/SkMemory_new_handler.cpp b/src/3rdparty/chromium/skia/ext/SkMemory_new_handler.cpp +index a6ae3c3..a94efec 100644 +--- a/src/3rdparty/chromium/skia/ext/SkMemory_new_handler.cpp ++++ b/src/3rdparty/chromium/skia/ext/SkMemory_new_handler.cpp +@@ -77,7 +77,7 @@ static void* malloc_nothrow(size_t size) { + // TODO(b.kelemen): we should always use UncheckedMalloc but currently it + // doesn't work as intended everywhere. + void* result; +-#if defined(OS_IOS) ++#if defined(OS_IOS) || defined(OS_HAIKU) + result = malloc(size); + #else + // It's the responsibility of the caller to check the return value. +@@ -97,7 +97,7 @@ static void* calloc_nothrow(size_t size) { + // TODO(b.kelemen): we should always use UncheckedCalloc but currently it + // doesn't work as intended everywhere. + void* result; +-#if defined(OS_IOS) ++#if defined(OS_IOS) || defined(OS_HAIKU) + result = calloc(1, size); + #else + // It's the responsibility of the caller to check the return value. +diff --git a/src/3rdparty/chromium/skia/ext/image_operations_unittest.cc b/src/3rdparty/chromium/skia/ext/image_operations_unittest.cc +index 8970955..253a551 100644 +--- a/src/3rdparty/chromium/skia/ext/image_operations_unittest.cc ++++ b/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); +diff --git a/src/3rdparty/chromium/third_party/angle/BUILD.gn b/src/3rdparty/chromium/third_party/angle/BUILD.gn +index ad7675f..0834640 100644 +--- a/src/3rdparty/chromium/third_party/angle/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/angle/BUILD.gn +@@ -362,6 +362,7 @@ angle_static_library("angle_gpu_info_util") { + "X11", + "Xi", + "Xext", ++ "GL", + ] + } + } +diff --git a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_internal.h b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_internal.h +index 21a7762..0189160 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_internal.h ++++ b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_internal.h +@@ -14,8 +14,13 @@ + namespace angle + { + ++bool CollectMesaCardInfo(std::vector *devices); ++ + // Defined in SystemInfo_libpci when GPU_INFO_USE_LIBPCI is defined. + bool GetPCIDevicesWithLibPCI(std::vector *devices); ++#if defined(__FreeBSD__) ++bool GetPCIDevicesFreeBSD(std::vector *devices); ++#endif + // Defined in SystemInfo_x11 when GPU_INFO_USE_X11 is defined. + bool GetNvidiaDriverVersionWithXNVCtrl(std::string *version); + +diff --git a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_libpci.cpp b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_libpci.cpp +index 21d9cbc..3d21668 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_libpci.cpp ++++ b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_libpci.cpp +@@ -12,6 +12,11 @@ + #include + #include + ++#if defined(__FreeBSD__) ++#include ++#include ++#endif ++ + #include "common/angleutils.h" + #include "common/debug.h" + +@@ -83,6 +88,75 @@ struct LibPCI : private angle::NonCopyable + + } // anonymous namespace + ++#if defined(__FreeBSD__) ++// Adds an entry per PCI GPU found and fills the device and vendor ID. ++bool GetPCIDevicesFreeBSD(std::vector *devices) ++{ ++ int fd; ++ struct pci_conf_io conf; ++ struct pci_conf *matches; ++ uint32_t offset = 0; ++ ++ fd = open("/dev/pci", O_RDONLY); ++ if (fd < 0) ++ return false; ++ ++ matches = new struct pci_conf[32]; ++ conf.generation = 0; ++ do { ++ conf.pat_buf_len = 0; ++ conf.num_patterns = 0; ++ conf.patterns = NULL; ++ conf.match_buf_len = 32 * sizeof(struct pci_conf); ++ conf.num_matches = 32; ++ conf.matches = matches; ++ conf.offset = offset; ++ conf.status = PCI_GETCONF_ERROR; ++ if (ioctl(fd, PCIOCGETCONF, &conf) < 0) { ++ if (errno == ENODEV) ++ break; ++ } ++ /* PCI_GETCONF_LIST_CHANGED would require us to start over. */ ++ if (conf.status == PCI_GETCONF_ERROR || conf.status == PCI_GETCONF_LIST_CHANGED) { ++ break; ++ } ++ ++ for (unsigned int i = 0; i < conf.num_matches; i++) { ++ uint16_t device_class = (matches[i].pc_class << 8) | matches[i].pc_subclass; ++ ++ // Skip non-GPU devices ++ switch (device_class) ++ { ++ case PCI_CLASS_DISPLAY_VGA: ++ case PCI_CLASS_DISPLAY_XGA: ++ case PCI_CLASS_DISPLAY_3D: ++ break; ++ default: ++ continue; ++ } ++ ++ // Skip unknown devices ++ if (matches[i].pc_vendor == 0 || matches[i].pc_device == 0) { ++ continue; ++ } ++ ++ GPUDeviceInfo info; ++ info.vendorId = matches[i].pc_vendor; ++ info.deviceId = matches[i].pc_device; ++ ++ devices->push_back(info); ++ } ++ offset += conf.num_matches; ++ } while (conf.status == PCI_GETCONF_MORE_DEVS); ++ ++ delete[] matches; ++ ++ close(fd); ++ ++ return true; ++} ++#endif ++ + // Adds an entry per PCI GPU found and fills the device and vendor ID. + bool GetPCIDevicesWithLibPCI(std::vector *devices) + { +diff --git a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_linux.cpp b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_linux.cpp +index 8bb7f3f..66757ac 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_linux.cpp ++++ b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_linux.cpp +@@ -71,10 +71,18 @@ bool GetPCIDevicesWithLibPCI(std::vector *devices) + + bool GetSystemInfo(SystemInfo *info) + { ++#if defined(__FreeBSD__) ++ if (!CollectMesaCardInfo(&(info->gpus))) ++ { ++ if (!GetPCIDevicesFreeBSD(&(info->gpus))) ++ return false; ++ } ++#else + if (!GetPCIDevicesWithLibPCI(&(info->gpus))) + { + return false; + } ++#endif + + if (info->gpus.size() == 0) + { +diff --git a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_x11.cpp b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_x11.cpp +index 0a58fc9..84a85bc 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_x11.cpp ++++ b/src/3rdparty/chromium/third_party/angle/src/gpu_info_util/SystemInfo_x11.cpp +@@ -8,6 +8,8 @@ + + #include "gpu_info_util/SystemInfo_internal.h" + ++#include ++#include + #include + + #include "common/debug.h" +@@ -18,9 +20,45 @@ + # error SystemInfo_x11.cpp compiled without GPU_INFO_USE_X11 + #endif + ++#define GLX_RENDERER_VENDOR_ID_MESA 0x8183 ++#define GLX_RENDERER_DEVICE_ID_MESA 0x8184 ++ + namespace angle + { + ++bool CollectMesaCardInfo(std::vector *devices) ++{ ++ ++ unsigned int vid[3], did[3]; ++ ++ Display *display = XOpenDisplay(NULL); ++ if (!display) { ++ return false; ++ } ++ ++ PFNGLXQUERYRENDERERINTEGERMESAPROC queryInteger = ++ (PFNGLXQUERYRENDERERINTEGERMESAPROC) glXGetProcAddressARB((const GLubyte *) ++ "glXQueryRendererIntegerMESA"); ++ ++ if (!queryInteger) ++ return false; ++ ++ bool vendor_ret = ++ queryInteger(display, 0, 0, GLX_RENDERER_VENDOR_ID_MESA, vid); ++ bool device_ret = ++ queryInteger(display, 0, 0, GLX_RENDERER_DEVICE_ID_MESA, did); ++ ++ if (vendor_ret && device_ret) { ++ GPUDeviceInfo info; ++ info.vendorId = vid[0]; ++ info.deviceId = did[0]; ++ devices->push_back(info); ++ } ++ ++ return true; ++} ++ ++ + bool GetNvidiaDriverVersionWithXNVCtrl(std::string *version) + { + *version = ""; +diff --git a/src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h b/src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h +index 7467899..9132b3f 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h ++++ b/src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h +@@ -9,6 +9,7 @@ + #ifndef LIBANGLE_CONSTANTS_H_ + #define LIBANGLE_CONSTANTS_H_ + ++#include + #include "common/platform.h" + + #include +diff --git a/src/3rdparty/chromium/third_party/angle/src/libANGLE/Display.cpp b/src/3rdparty/chromium/third_party/angle/src/libANGLE/Display.cpp +index f3b6ebf..b14bfaa 100644 +--- a/src/3rdparty/chromium/third_party/angle/src/libANGLE/Display.cpp ++++ b/src/3rdparty/chromium/third_party/angle/src/libANGLE/Display.cpp +@@ -54,7 +54,7 @@ + # include "libANGLE/renderer/gl/cgl/DisplayCGL.h" + # elif defined(ANGLE_PLATFORM_IOS) + # include "libANGLE/renderer/gl/eagl/DisplayEAGL.h" +-# elif defined(ANGLE_PLATFORM_LINUX) ++# elif defined(ANGLE_PLATFORM_POSIX) + # if defined(ANGLE_USE_OZONE) + # include "libANGLE/renderer/gl/egl/ozone/DisplayOzone.h" + # else +@@ -252,7 +252,7 @@ rx::DisplayImpl *CreateDisplayFromAttribs(EGLAttrib displayType, + impl = new rx::DisplayCGL(state); + # elif defined(ANGLE_PLATFORM_IOS) + impl = new rx::DisplayEAGL(state); +-# elif defined(ANGLE_PLATFORM_LINUX) ++# elif defined(ANGLE_PLATFORM_POSIX) + # if defined(ANGLE_USE_OZONE) + // This might work but has never been tried, so disallow for now. + impl = nullptr; +@@ -284,7 +284,7 @@ rx::DisplayImpl *CreateDisplayFromAttribs(EGLAttrib displayType, + #if defined(ANGLE_ENABLE_OPENGL) + # if defined(ANGLE_PLATFORM_WINDOWS) + impl = new rx::DisplayWGL(state); +-# elif defined(ANGLE_PLATFORM_LINUX) ++# elif defined(ANGLE_PLATFORM_POSIX) + # if defined(ANGLE_USE_OZONE) + impl = new rx::DisplayOzone(state); + # else +@@ -315,7 +315,7 @@ rx::DisplayImpl *CreateDisplayFromAttribs(EGLAttrib displayType, + { + impl = rx::CreateVulkanWin32Display(state); + } +-# elif defined(ANGLE_PLATFORM_LINUX) ++# elif defined(ANGLE_PLATFORM_POSIX) + if (rx::IsVulkanXcbDisplayAvailable()) + { + impl = rx::CreateVulkanXcbDisplay(state); +@@ -1387,7 +1387,7 @@ static ClientExtensions GenerateClientExtensions() + extensions.x11Visual = true; + #endif + +-#if defined(ANGLE_PLATFORM_LINUX) && !defined(ANGLE_USE_OZONE) ++#if defined(ANGLE_PLATFORM_POSIX) && !defined(ANGLE_USE_OZONE) + extensions.platformANGLEDeviceTypeEGLANGLE = true; + #endif + +diff --git a/src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S b/src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S +index ef6c332..32d65b4 100644 +--- a/src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S ++++ b/src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S +@@ -1,3 +1,63 @@ ++/* ++ * 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 ++ + /* + * typedef void (*PushAllRegistersCallback)(ThreadState*, intptr_t*); + * extern "C" void PushAllRegisters(ThreadState*, PushAllRegistersCallback) +diff --git a/src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc b/src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc +index 29375a5..f9dfff4 100644 +--- a/src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc ++++ b/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(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(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 +diff --git a/src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h b/src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h +index 2693fa6..92d6691 100644 +--- a/src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h ++++ b/src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h +@@ -67,11 +67,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)); + } + +diff --git a/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h b/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h +index 8d73f77..e361a16 100644 +--- a/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h ++++ b/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h +@@ -96,9 +96,13 @@ extern "C" { + #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 +diff --git a/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/cpu.h b/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/cpu.h +index ae55967..4a1b310 100644 +--- a/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/cpu.h ++++ b/src/3rdparty/chromium/third_party/boringssl/src/include/openssl/cpu.h +@@ -105,7 +105,7 @@ OPENSSL_INLINE const uint32_t *OPENSSL_ia32cap_get(void) { + + #if defined(OPENSSL_ARM) || defined(OPENSSL_AARCH64) + +-#if defined(OPENSSL_APPLE) ++#if defined(OPENSSL_APPLE) || defined(__FreeBSD__) + // iOS builds use the static ARM configuration. + #define OPENSSL_STATIC_ARMCAP + #endif +diff --git a/src/3rdparty/chromium/third_party/breakpad/breakpad/src/common/simple_string_dictionary.h b/src/3rdparty/chromium/third_party/breakpad/breakpad/src/common/simple_string_dictionary.h +index 9484920..a1166a2 100644 +--- a/src/3rdparty/chromium/third_party/breakpad/breakpad/src/common/simple_string_dictionary.h ++++ b/src/3rdparty/chromium/third_party/breakpad/breakpad/src/common/simple_string_dictionary.h +@@ -33,7 +33,7 @@ + #include + #include + +-#include "common/basictypes.h" ++#include "third_party/breakpad/breakpad/src/common/basictypes.h" + + namespace google_breakpad { + +diff --git a/src/3rdparty/chromium/third_party/crc32c/BUILD.gn b/src/3rdparty/chromium/third_party/crc32c/BUILD.gn +index 5ea81e4..2747779 100644 +--- a/src/3rdparty/chromium/third_party/crc32c/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/crc32c/BUILD.gn +@@ -16,13 +16,10 @@ 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 += [ + "HAVE_MM_PREFETCH=1", +diff --git a/src/3rdparty/chromium/third_party/crc32c/src/src/crc32c_arm64_linux_check.h b/src/3rdparty/chromium/third_party/crc32c/src/src/crc32c_arm64_linux_check.h +index 6817979..f5fe1cb 100644 +--- a/src/3rdparty/chromium/third_party/crc32c/src/src/crc32c_arm64_linux_check.h ++++ b/src/3rdparty/chromium/third_party/crc32c/src/src/crc32c_arm64_linux_check.h +@@ -16,6 +16,29 @@ + + #if HAVE_ARM64_CRC32C + ++#if defined(__FreeBSD__) ++#include ++#ifndef ID_AA64ISAR0_AES_VAL ++#define ID_AA64ISAR0_AES_VAL ID_AA64ISAR0_AES ++#endif ++#ifndef ID_AA64ISAR0_CRC32_VAL ++#define ID_AA64ISAR0_CRC32_VAL ID_AA64ISAR0_CRC32 ++#endif ++namespace crc32c { ++ ++inline bool CanUseArm64Linux() { ++ uint64_t id_aa64isar0; ++ ++ id_aa64isar0 = READ_SPECIALREG(id_aa64isar0_el1); ++ if ((ID_AA64ISAR0_AES_VAL(id_aa64isar0) == ID_AA64ISAR0_AES_PMULL) && \ ++ (ID_AA64ISAR0_CRC32_VAL(id_aa64isar0) == ID_AA64ISAR0_CRC32_BASE)) ++ return true; ++ return false; ++} ++ ++} // namespace crc32c ++ ++#elif defined(__linux__) + #if HAVE_STRONG_GETAUXVAL + #include + #elif HAVE_WEAK_GETAUXVAL +@@ -43,6 +66,7 @@ inline bool CanUseArm64Linux() { + + } // namespace crc32c + ++#endif + #endif // HAVE_ARM64_CRC32C + + #endif // CRC32C_CRC32C_ARM_LINUX_CHECK_H_ +diff --git a/src/3rdparty/chromium/third_party/ffmpeg/BUILD.gn b/src/3rdparty/chromium/third_party/ffmpeg/BUILD.gn +index 5371e47..92f4410 100755 +--- a/src/3rdparty/chromium/third_party/ffmpeg/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/ffmpeg/BUILD.gn +@@ -10,8 +10,13 @@ import("//build/config/compiler/compiler.gni") + import("//build/config/sanitizers/sanitizers.gni") + + # Path to platform configuration files. +-platform_config_root = +- "chromium/config/$ffmpeg_branding/$os_config/$ffmpeg_arch" ++if (!is_haiku) { ++ platform_config_root = ++ "chromium/config/$ffmpeg_branding/$os_config/$ffmpeg_arch" ++} else { ++ platform_config_root = ++ "chromium/config/$ffmpeg_branding/linux/$ffmpeg_arch" ++} + + has_nasm_deps = + ffmpeg_asm_sources != [] && +diff --git a/src/3rdparty/chromium/third_party/ffmpeg/libavutil/mem.c b/src/3rdparty/chromium/third_party/ffmpeg/libavutil/mem.c +index 99b730c..11af642 100644 +--- a/src/3rdparty/chromium/third_party/ffmpeg/libavutil/mem.c ++++ b/src/3rdparty/chromium/third_party/ffmpeg/libavutil/mem.c +@@ -32,9 +32,6 @@ + #include + #include + #include +-#if HAVE_MALLOC_H +-#include +-#endif + + #include "avassert.h" + #include "avutil.h" +diff --git a/src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h b/src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h +index 6a9f74e..ec7eb94 100644 +--- a/src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h ++++ b/src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h +@@ -20,8 +20,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: +diff --git a/src/3rdparty/chromium/third_party/libXNVCtrl/NVCtrl.c b/src/3rdparty/chromium/third_party/libXNVCtrl/NVCtrl.c +index 6eacc95..4fb7f3a 100644 +--- a/src/3rdparty/chromium/third_party/libXNVCtrl/NVCtrl.c ++++ b/src/3rdparty/chromium/third_party/libXNVCtrl/NVCtrl.c +@@ -27,10 +27,6 @@ + * libXNVCtrl library properly protects the Display connection. + */ + +-#if !defined(XTHREADS) +-#define XTHREADS +-#endif /* XTHREADS */ +- + #define NEED_EVENTS + #define NEED_REPLIES + #include +@@ -39,6 +35,11 @@ + #include + #include + #include ++ ++#if !defined(XTHREADS) ++#define XTHREADS ++#endif /* XTHREADS */ ++ + #include "NVCtrlLib.h" + #include "nv_control.h" + +diff --git a/src/3rdparty/chromium/third_party/libpng/BUILD.gn b/src/3rdparty/chromium/third_party/libpng/BUILD.gn +index 02d090b..1727781 100644 +--- a/src/3rdparty/chromium/third_party/libpng/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/libpng/BUILD.gn +@@ -91,6 +91,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" ] +diff --git a/src/3rdparty/chromium/third_party/libyuv/include/libyuv/row.h b/src/3rdparty/chromium/third_party/libyuv/include/libyuv/row.h +index b721858..a86710a 100644 +--- a/src/3rdparty/chromium/third_party/libyuv/include/libyuv/row.h ++++ b/src/3rdparty/chromium/third_party/libyuv/include/libyuv/row.h +@@ -157,10 +157,14 @@ extern "C" { + #define HAS_ARGBSHADEROW_SSE2 + #define HAS_ARGBSUBTRACTROW_SSE2 + #define HAS_ARGBUNATTENUATEROW_SSE2 ++#if !(defined(__i386__) && defined(__GNUC__)) + #define HAS_BLENDPLANEROW_SSSE3 ++#endif + #define HAS_COMPUTECUMULATIVESUMROW_SSE2 + #define HAS_CUMULATIVESUMTOAVERAGEROW_SSE2 ++#if !(defined(__i386__) && defined(__GNUC__)) + #define HAS_INTERPOLATEROW_SSSE3 ++#endif + #define HAS_RGBCOLORTABLEROW_X86 + #define HAS_SOBELROW_SSE2 + #define HAS_SOBELTOPLANEROW_SSE2 +@@ -206,7 +210,9 @@ extern "C" { + #define HAS_I422TORGB565ROW_AVX2 + #define HAS_I422TORGBAROW_AVX2 + #define HAS_I444TOARGBROW_AVX2 ++#if !(defined(__i386__) && defined(__GNUC__)) + #define HAS_INTERPOLATEROW_AVX2 ++#endif + #define HAS_J422TOARGBROW_AVX2 + #define HAS_MERGEUVROW_AVX2 + #define HAS_MIRRORROW_AVX2 +@@ -231,7 +237,9 @@ extern "C" { + #define HAS_ARGBMULTIPLYROW_AVX2 + #define HAS_ARGBSUBTRACTROW_AVX2 + #define HAS_ARGBUNATTENUATEROW_AVX2 ++#if !(defined(__i386__) && defined(__GNUC__)) + #define HAS_BLENDPLANEROW_AVX2 ++#endif + + #if defined(__x86_64__) || !defined(__pic__) || defined(__clang__) || \ + defined(_MSC_VER) +diff --git a/src/3rdparty/chromium/third_party/modp_b64/BUILD.gn b/src/3rdparty/chromium/third_party/modp_b64/BUILD.gn +index 539abe1..981d8b6 100644 +--- a/src/3rdparty/chromium/third_party/modp_b64/BUILD.gn ++++ b/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" ] ++ } + } +diff --git a/src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc b/src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc +index fdb8a40..a70b080 100644 +--- a/src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc ++++ b/src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc +@@ -118,7 +118,7 @@ size_t modp_b64_encode(char* dest, const char* str, size_t len) + } + + #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; + +diff --git a/src/3rdparty/chromium/third_party/node/node.py b/src/3rdparty/chromium/third_party/node/node.py +index 8097e2c..75e7d15 100755 +--- a/src/3rdparty/chromium/third_party/node/node.py ++++ b/src/3rdparty/chromium/third_party/node/node.py +@@ -12,6 +12,7 @@ import sys + def GetBinaryPath(): + return os_path.join(os_path.dirname(__file__), *{ + 'Darwin': ('mac', 'node-darwin-x64', 'bin', 'node'), ++ 'Haiku': ('haiku', 'node-haiku-x64', 'bin', 'node'), + 'Linux': ('linux', 'node-linux-x64', 'bin', 'node'), + 'Windows': ('win', 'node.exe'), + }[platform.system()]) +diff --git a/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/stubs/platform_macros.h b/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/stubs/platform_macros.h +index ce1b1e3..fb93f21 100644 +--- a/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/stubs/platform_macros.h ++++ b/src/3rdparty/chromium/third_party/protobuf/src/google/protobuf/stubs/platform_macros.h +@@ -118,7 +118,7 @@ GOOGLE_PROTOBUF_PLATFORM_ERROR + + #undef GOOGLE_PROTOBUF_PLATFORM_ERROR + +-#if defined(GOOGLE_PROTOBUF_OS_ANDROID) || defined(GOOGLE_PROTOBUF_OS_IPHONE) || defined(__OpenBSD__) ++#if defined(GOOGLE_PROTOBUF_OS_ANDROID) || defined(GOOGLE_PROTOBUF_OS_IPHONE) || defined(__FreeBSD__) + // Android ndk does not support the __thread keyword very well yet. Here + // we use pthread_key_create()/pthread_getspecific()/... methods for + // TLS support on android. +diff --git a/src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp b/src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp +index 0303624..7f31d51 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp ++++ b/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 <> +diff --git a/src/3rdparty/chromium/third_party/skia/src/core/SkCpu.cpp b/src/3rdparty/chromium/third_party/skia/src/core/SkCpu.cpp +index 1326a0f..66cf7fe 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/core/SkCpu.cpp ++++ b/src/3rdparty/chromium/third_party/skia/src/core/SkCpu.cpp +@@ -72,6 +72,23 @@ + return features; + } + ++#elif defined(SK_CPU_ARM64) && defined(__FreeBSD__) ++ #include ++ #ifndef ID_AA64ISAR0_CRC32_VAL ++ #define ID_AA64ISAR0_CRC32_VAL ID_AA64ISAR0_CRC32 ++ #endif ++ ++ static uint32_t read_cpu_features() { ++ uint32_t features = 0; ++ uint64_t id_aa64isar0; ++ ++ id_aa64isar0 = READ_SPECIALREG(id_aa64isar0_el1); ++ if (ID_AA64ISAR0_CRC32_VAL(id_aa64isar0) == ID_AA64ISAR0_CRC32_BASE) { ++ features |= SkCpu::CRC32; ++ } ++ return features; ++ } ++ + #elif defined(SK_CPU_ARM64) && __has_include() + #include + +@@ -80,7 +97,12 @@ + kHWCAP_ASIMDHP = (1<<10); + + uint32_t features = 0; ++#if defined(__FreeBSD__) ++ uint32_t hwcaps = 0; ++ elf_aux_info(AT_HWCAP, &hwcaps, sizeof(hwcaps)); ++#else + uint32_t hwcaps = getauxval(AT_HWCAP); ++#endif + if (hwcaps & kHWCAP_CRC32 ) { features |= SkCpu::CRC32; } + if (hwcaps & kHWCAP_ASIMDHP) { features |= SkCpu::ASIMDHP; } + +diff --git a/src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp b/src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp +index 1e6ddd1..0e71c31 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp ++++ b/src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp +@@ -268,7 +268,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()) { +diff --git a/src/3rdparty/chromium/third_party/skia/src/images/SkJpegEncoder.cpp b/src/3rdparty/chromium/third_party/skia/src/images/SkJpegEncoder.cpp +index b87d73a..2415dfa 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/images/SkJpegEncoder.cpp ++++ b/src/3rdparty/chromium/third_party/skia/src/images/SkJpegEncoder.cpp +@@ -76,9 +76,14 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder + return (transform_scanline_proc) nullptr; + }; + ++#ifdef JCS_EXTENSIONS + J_COLOR_SPACE jpegColorType = JCS_EXT_RGBA; ++#else ++ J_COLOR_SPACE jpegColorType = JCS_RGB; ++#endif + int numComponents = 0; + switch (srcInfo.colorType()) { ++#ifdef JCS_EXTENSIONS + case kRGBA_8888_SkColorType: + fProc = chooseProc8888(); + jpegColorType = JCS_EXT_RGBA; +@@ -89,6 +94,7 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder + jpegColorType = JCS_EXT_BGRA; + numComponents = 4; + break; ++#endif + case kRGB_565_SkColorType: + fProc = transform_scanline_565; + jpegColorType = JCS_RGB; +@@ -108,6 +114,7 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder + jpegColorType = JCS_GRAYSCALE; + numComponents = 1; + break; ++#ifdef JCS_EXTENSIONS + case kRGBA_F16_SkColorType: + if (kUnpremul_SkAlphaType == srcInfo.alphaType() && + options.fAlphaOption == SkJpegEncoder::AlphaOption::kBlendOnBlack) { +@@ -118,6 +125,7 @@ bool SkJpegEncoderMgr::setParams(const SkImageInfo& srcInfo, const SkJpegEncoder + jpegColorType = JCS_EXT_RGBA; + numComponents = 4; + break; ++#endif + default: + return false; + } +diff --git a/src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h b/src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h +index 41e8168..8de6841 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h ++++ b/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], +diff --git a/src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h b/src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h +index 8e4a8fd..afdaae8 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h ++++ b/src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h +@@ -365,8 +365,8 @@ void blit_row_s32a_opaque(SkPMColor* dst, const SkPMColor* src, int len, U8CPU a + // 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++; +diff --git a/src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h b/src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h +index 831f5b3..9938667 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h ++++ b/src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h +@@ -988,9 +988,7 @@ SI F approx_powf(F x, F y) { + SI F from_half(U16 h) { + #if defined(JUMPER_IS_NEON) && defined(SK_CPU_ARM64) \ + && !defined(SK_BUILD_FOR_GOOGLE3) // Temporary workaround for some Google3 builds. +- __fp16 fp16; +- memcpy(&fp16, &h, sizeof(U16)); +- return float(fp16); ++ return vcvt_f32_f16(h); + + #elif defined(JUMPER_IS_HSW) || defined(JUMPER_IS_AVX512) + return _mm256_cvtph_ps(h); +@@ -1011,10 +1009,7 @@ SI F from_half(U16 h) { + SI U16 to_half(F f) { + #if defined(JUMPER_IS_NEON) && defined(SK_CPU_ARM64) \ + && !defined(SK_BUILD_FOR_GOOGLE3) // Temporary workaround for some Google3 builds. +- __fp16 fp16 = __fp16(f); +- U16 u16; +- memcpy(&u16, &fp16, sizeof(U16)); +- return u16; ++ return vcvt_f16_f32(f); + + #elif defined(JUMPER_IS_HSW) || defined(JUMPER_IS_AVX512) + return _mm256_cvtps_ph(f, _MM_FROUND_CUR_DIRECTION); +diff --git a/src/3rdparty/chromium/third_party/skia/src/ports/SkOSFile_stdio.cpp b/src/3rdparty/chromium/third_party/skia/src/ports/SkOSFile_stdio.cpp +index 201cbbf..7234e3c 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/ports/SkOSFile_stdio.cpp ++++ b/src/3rdparty/chromium/third_party/skia/src/ports/SkOSFile_stdio.cpp +@@ -132,7 +132,7 @@ void sk_fflush(FILE* f) { + + void sk_fsync(FILE* f) { + #if !defined(_WIN32) && !defined(SK_BUILD_FOR_ANDROID) && !defined(__UCLIBC__) \ +- && !defined(_NEWLIB_VERSION) ++ && !defined(_NEWLIB_VERSION) && !defined(__FreeBSD__) + int fd = fileno(f); + fsync(fd); + #endif +diff --git a/src/3rdparty/chromium/third_party/skia/src/sksl/SkSLString.h b/src/3rdparty/chromium/third_party/skia/src/sksl/SkSLString.h +index c60a748..a1c63dc 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/sksl/SkSLString.h ++++ b/src/3rdparty/chromium/third_party/skia/src/sksl/SkSLString.h +@@ -17,6 +17,8 @@ + #include "include/core/SkString.h" + #endif + ++#include ++ + namespace SkSL { + + // Represents a (not necessarily null-terminated) slice of a string. +diff --git a/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp b/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp +index 181ca75..a68cfb9 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp ++++ b/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() = reinterpret_cast(p); + + if (sizeof(Value) == sizeof(uintptr_t)) { +@@ -169,7 +173,7 @@ 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 + } + }; +diff --git a/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h b/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h +index 931b30f..0a28d00 100644 +--- a/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h ++++ b/src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h +@@ -120,6 +120,7 @@ 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 @@ 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 @@ private: + + 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(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(kTagMask); + #endif + }; + +diff --git a/src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc b/src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc +index dde373c..9ccaec9 100644 +--- a/src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc ++++ b/src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc +@@ -222,10 +222,15 @@ static float eval_curve(const skcms_Curve* curve, float x) { + 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; + } +@@ -281,21 +286,29 @@ 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 + } + + static int32_t read_big_i32(const uint8_t* ptr) { +diff --git a/src/3rdparty/chromium/third_party/skia/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h b/src/3rdparty/chromium/third_party/skia/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h +index 9caf759..af2595f 100644 +--- a/src/3rdparty/chromium/third_party/skia/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h ++++ b/src/3rdparty/chromium/third_party/skia/third_party/vulkanmemoryallocator/include/vk_mem_alloc.h +@@ -2232,7 +2232,7 @@ remove them if not needed. + #include // for std::mutex + #include // for std::atomic + +-#if !defined(_WIN32) && !defined(__APPLE__) ++#if !defined(_WIN32) && !defined(__APPLE__) && !defined(__FreeBSD__) + #include // for aligned_alloc() + #endif + +diff --git a/src/3rdparty/chromium/third_party/smhasher/src/City.cpp b/src/3rdparty/chromium/third_party/smhasher/src/City.cpp +index d7c33bc..1360e2e 100644 +--- a/src/3rdparty/chromium/third_party/smhasher/src/City.cpp ++++ b/src/3rdparty/chromium/third_party/smhasher/src/City.cpp +@@ -65,11 +65,11 @@ static uint32 UNALIGNED_LOAD32(const char *p) { + #define bswap_64(x) OSSwapInt64(x) + + #else +-#include ++#include + #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__ + +diff --git a/src/3rdparty/chromium/third_party/usrsctp/BUILD.gn b/src/3rdparty/chromium/third_party/usrsctp/BUILD.gn +index e8a5b1f..840cd42 100644 +--- a/src/3rdparty/chromium/third_party/usrsctp/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/usrsctp/BUILD.gn +@@ -121,11 +121,15 @@ static_library("usrsctp") { + "-UINET6", + ] + +- if (is_linux || is_android) { ++ if ((is_linux && !is_haiku) || is_android ) { + defines += [ + "__Userspace_os_Linux", + "_GNU_SOURCE", + ] ++ } else if (is_haiku) { ++ defines += [ ++ "__Userspace_os_Haiku", ++ ] + } else if (is_mac || is_ios) { + defines += [ + "HAVE_SA_LEN", +diff --git a/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_os_userspace.h b/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_os_userspace.h +index f09cb8d..121134c 100755 +--- a/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_os_userspace.h ++++ b/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_os_userspace.h +@@ -1155,7 +1155,7 @@ sctp_get_mbuf_for_msg(unsigned int space_needed, int want_header, int how, int a + + #define SCTP_IS_LISTENING(inp) ((inp->sctp_flags & SCTP_PCB_FLAGS_ACCEPTING) != 0) + +-#if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_Linux) || defined(__Userspace_os_NaCl) || defined(__Userspace_os_NetBSD) || defined(__Userspace_os_Windows) || defined(__Userspace_os_Fuchsia) ++#if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_Linux) || defined(__Userspace_os_NaCl) || defined(__Userspace_os_NetBSD) || defined(__Userspace_os_Windows) || defined(__Userspace_os_Fuchsia) || defined(__Userspace_os_Haiku) + int + timingsafe_bcmp(const void *, const void *, size_t); + #endif +diff --git a/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_userspace.c b/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_userspace.c +index 41987be..da36bd8 100755 +--- a/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_userspace.c ++++ b/src/3rdparty/chromium/third_party/usrsctp/usrsctplib/usrsctplib/netinet/sctp_userspace.c +@@ -132,7 +132,7 @@ sctp_userspace_get_mtu_from_ifn(uint32_t if_index, int af) + } + #endif + +-#if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_Linux) || defined(__Userspace_os_NaCl) || defined(__Userspace_os_NetBSD) || defined(__Userspace_os_Windows) || defined(__Userspace_os_Fuchsia) ++#if defined(__Userspace_os_Darwin) || defined(__Userspace_os_DragonFly) || defined(__Userspace_os_Linux) || defined(__Userspace_os_NaCl) || defined(__Userspace_os_NetBSD) || defined(__Userspace_os_Windows) || defined(__Userspace_os_Fuchsia) || defined(__Userspace_os_Haiku) + int + timingsafe_bcmp(const void *b1, const void *b2, size_t n) + { +diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/audio_device/BUILD.gn b/src/3rdparty/chromium/third_party/webrtc/modules/audio_device/BUILD.gn +index 2ce0ae2..d334352 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/modules/audio_device/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/webrtc/modules/audio_device/BUILD.gn +@@ -259,7 +259,7 @@ rtc_library("audio_device_impl") { + if (rtc_use_dummy_audio_file_devices) { + defines += [ "WEBRTC_DUMMY_FILE_DEVICES" ] + } else { +- if (is_linux) { ++ if (is_linux && !is_haiku) { + sources += [ + "linux/alsasymboltable_linux.cc", + "linux/alsasymboltable_linux.h", +diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc +index dd9ab45..c005d95 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc ++++ b/src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc +@@ -30,11 +30,7 @@ bool VectorDifference(const uint8_t* image1, const uint8_t* image2) { + 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 uint8_t* image2) { + } else { + diff_proc = &VectorDifference_C; + } ++#else ++ // For other processors, always use C version. ++ // TODO(hclam): Implement a NEON version. ++ diff_proc = &VectorDifference_C; + #endif + } + +diff --git a/src/3rdparty/chromium/third_party/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc b/src/3rdparty/chromium/third_party/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc +index 1812fbf..3635be9 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc ++++ b/src/3rdparty/chromium/third_party/webrtc/modules/rtp_rtcp/source/forward_error_correction.cc +@@ -13,6 +13,7 @@ + #include + + #include ++#include + #include + + #include "absl/algorithm/container.h" +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/byte_order.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/byte_order.h +index ae1c634..ac44ba3 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/byte_order.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/byte_order.h +@@ -89,7 +89,7 @@ + #endif // defined(WEBRTC_ARCH_LITTLE_ENDIAN) + + #elif defined(WEBRTC_POSIX) +-#include ++#include + #else + #error "Missing byte order functions for this arch." + #endif // defined(WEBRTC_MAC) +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/ifaddrs_converter.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/ifaddrs_converter.h +index bd6957d..2d729c1 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/ifaddrs_converter.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/ifaddrs_converter.h +@@ -14,6 +14,8 @@ + #if defined(WEBRTC_ANDROID) + #include "rtc_base/ifaddrs_android.h" + #else ++#include ++#include + #include + #endif // WEBRTC_ANDROID + +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/ip_address.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/ip_address.h +index ae135a6..68f8ccc 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/ip_address.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/ip_address.h +@@ -17,6 +17,10 @@ + #include + #include + #endif ++#if defined(WEBRTC_BSD) ++#include ++#include ++#endif + #if defined(WEBRTC_WIN) + #include + #include +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/network.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/network.h +index ed601a5..4637ced 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/network.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/network.h +@@ -26,6 +26,10 @@ + #include "rtc_base/system/rtc_export.h" + #include "rtc_base/third_party/sigslot/sigslot.h" + ++#if defined(WEBRTC_BSD) ++#include ++#endif ++ + #if defined(WEBRTC_POSIX) + struct ifaddrs; + #endif // defined(WEBRTC_POSIX) +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/physical_socket_server.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/physical_socket_server.h +index a71810f..0b952e3 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/physical_socket_server.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/physical_socket_server.h +@@ -11,7 +11,7 @@ + #ifndef RTC_BASE_PHYSICAL_SOCKET_SERVER_H_ + #define RTC_BASE_PHYSICAL_SOCKET_SERVER_H_ + +-#if defined(WEBRTC_POSIX) && defined(WEBRTC_LINUX) ++#if defined(WEBRTC_POSIX) && defined(WEBRTC_LINUX) && !defined(WEBRTC_BSD) + #include + #define WEBRTC_USE_EPOLL 1 + #endif +diff --git a/src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h b/src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h +index ed216e6..25d36c0 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h ++++ b/src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h +@@ -50,6 +50,18 @@ + #elif defined(__EMSCRIPTEN__) + #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 rtc_base/system/arch.h + #endif +diff --git a/src/3rdparty/chromium/third_party/zlib/BUILD.gn b/src/3rdparty/chromium/third_party/zlib/BUILD.gn +index 00d1e7c..a5b9fed 100644 +--- a/src/3rdparty/chromium/third_party/zlib/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/zlib/BUILD.gn +@@ -383,7 +383,7 @@ static_library("bundled_minizip") { + ] + } + +- if (is_mac || is_ios || is_android || is_nacl) { ++ if (is_mac || is_ios || is_android || is_nacl || is_haiku) { + # Mac, Android and the BSDs don't have fopen64, ftello64, or fseeko64. We + # use fopen, ftell, and fseek instead on these systems. + defines = [ "USE_FILE32API" ] +diff --git a/src/3rdparty/chromium/third_party/zlib/cpu_features.c b/src/3rdparty/chromium/third_party/zlib/cpu_features.c +index ceed988..5548443 100644 +--- a/src/3rdparty/chromium/third_party/zlib/cpu_features.c ++++ b/src/3rdparty/chromium/third_party/zlib/cpu_features.c +@@ -24,11 +24,20 @@ int ZLIB_INTERNAL x86_cpu_enable_simd = 0; + + #ifndef CPU_NO_SIMD + +-#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA) ++#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA) || defined(ARMV8_OS_FREEBSD) + #include + #endif + +-#if defined(ARMV8_OS_ANDROID) ++#if defined(ARMV8_OS_FREEBSD) ++#include ++#include ++#ifndef ID_AA64ISAR0_AES_VAL ++#define ID_AA64ISAR0_AES_VAL ID_AA64ISAR0_AES ++#endif ++#ifndef ID_AA64ISAR0_CRC32_VAL ++#define ID_AA64ISAR0_CRC32_VAL ID_AA64ISAR0_CRC32 ++#endif ++#elif defined(ARMV8_OS_ANDROID) + #include + #elif defined(ARMV8_OS_LINUX) + #include +@@ -49,7 +58,7 @@ int ZLIB_INTERNAL x86_cpu_enable_simd = 0; + static void _cpu_check_features(void); + #endif + +-#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA) || defined(X86_NOT_WINDOWS) ++#if defined(ARMV8_OS_ANDROID) || defined(ARMV8_OS_LINUX) || defined(ARMV8_OS_FUCHSIA) || defined(X86_NOT_WINDOWS) || defined(ARMV8_OS_FREEBSD) + static pthread_once_t cpu_check_inited_once = PTHREAD_ONCE_INIT; + void ZLIB_INTERNAL cpu_check_features(void) + { +@@ -108,6 +117,13 @@ static void _cpu_check_features(void) + #elif defined(ARMV8_OS_WINDOWS) + arm_cpu_enable_crc32 = IsProcessorFeaturePresent(PF_ARM_V8_CRC32_INSTRUCTIONS_AVAILABLE); + arm_cpu_enable_pmull = IsProcessorFeaturePresent(PF_ARM_V8_CRYPTO_INSTRUCTIONS_AVAILABLE); ++#elif defined(ARMV8_OS_FREEBSD) ++ uint64_t id_aa64isar0; ++ id_aa64isar0 = READ_SPECIALREG(id_aa64isar0_el1); ++ if (ID_AA64ISAR0_AES_VAL(id_aa64isar0) == ID_AA64ISAR0_AES_PMULL) ++ arm_cpu_enable_pmull = 1; ++ if (ID_AA64ISAR0_CRC32_VAL(id_aa64isar0) == ID_AA64ISAR0_CRC32_BASE) ++ arm_cpu_enable_crc32 = 1; + #endif + } + #endif +@@ -145,4 +161,4 @@ static void _cpu_check_features(void) + } + #endif + #endif +-#endif +\ No newline at end of file ++#endif +diff --git a/src/3rdparty/chromium/tools/json_schema_compiler/feature_compiler.py b/src/3rdparty/chromium/tools/json_schema_compiler/feature_compiler.py +index f8975c0..a475785 100644 +--- a/src/3rdparty/chromium/tools/json_schema_compiler/feature_compiler.py ++++ b/src/3rdparty/chromium/tools/json_schema_compiler/feature_compiler.py +@@ -219,6 +219,7 @@ FEATURE_GRAMMAR = ( + 'enum_map': { + 'chromeos': 'Feature::CHROMEOS_PLATFORM', + 'linux': 'Feature::LINUX_PLATFORM', ++ 'haiku': 'Feature::LINUX_PLATFORM', + 'mac': 'Feature::MACOSX_PLATFORM', + 'win': 'Feature::WIN_PLATFORM', + } +diff --git a/src/3rdparty/chromium/tools/json_schema_compiler/model.py b/src/3rdparty/chromium/tools/json_schema_compiler/model.py +index cafd0e1..d2a4358 100644 +--- a/src/3rdparty/chromium/tools/json_schema_compiler/model.py ++++ b/src/3rdparty/chromium/tools/json_schema_compiler/model.py +@@ -605,7 +605,7 @@ class Platforms(object): + """ + CHROMEOS = _PlatformInfo("chromeos") + CHROMEOS_TOUCH = _PlatformInfo("chromeos_touch") +- LINUX = _PlatformInfo("linux") ++ LINUX = _PlatformInfo("haiku") + MAC = _PlatformInfo("mac") + WIN = _PlatformInfo("win") + +diff --git a/src/3rdparty/chromium/tools/variations/fieldtrial_to_struct.py b/src/3rdparty/chromium/tools/variations/fieldtrial_to_struct.py +index 65f9c9b..82c9570 100755 +--- a/src/3rdparty/chromium/tools/variations/fieldtrial_to_struct.py ++++ b/src/3rdparty/chromium/tools/variations/fieldtrial_to_struct.py +@@ -35,6 +35,7 @@ _platforms = [ + 'android_weblayer', + 'android_webview', + 'chromeos', ++ 'haiku', + 'fuchsia', + 'ios', + 'linux', +diff --git a/src/3rdparty/chromium/ui/base/dragdrop/os_exchange_data_provider_factory.cc b/src/3rdparty/chromium/ui/base/dragdrop/os_exchange_data_provider_factory.cc +index 5d06130..a20d368 100644 +--- a/src/3rdparty/chromium/ui/base/dragdrop/os_exchange_data_provider_factory.cc ++++ b/src/3rdparty/chromium/ui/base/dragdrop/os_exchange_data_provider_factory.cc +@@ -8,7 +8,7 @@ + + #if defined(USE_X11) + #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h" +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + #include "ui/base/dragdrop/os_exchange_data_provider_aura.h" + #elif defined(OS_MACOSX) + #include "ui/base/dragdrop/os_exchange_data_provider_builder_mac.h" +@@ -24,7 +24,7 @@ std::unique_ptr + OSExchangeDataProviderFactory::CreateProvider() { + #if defined(USE_X11) + return std::make_unique(); +-#elif defined(OS_LINUX) ++#elif defined(OS_LINUX) || defined(OS_HAIKU) + return std::make_unique(); + #elif defined(OS_MACOSX) + return ui::BuildOSExchangeDataProviderMac(); +diff --git a/src/3rdparty/chromium/ui/base/ime/init/input_method_initializer.cc b/src/3rdparty/chromium/ui/base/ime/init/input_method_initializer.cc +index e903d1b..a7c729c 100644 +--- a/src/3rdparty/chromium/ui/base/ime/init/input_method_initializer.cc ++++ b/src/3rdparty/chromium/ui/base/ime/init/input_method_initializer.cc +@@ -8,7 +8,7 @@ + + #if defined(OS_CHROMEOS) + #include "ui/base/ime/ime_bridge.h" +-#elif defined(USE_AURA) && defined(OS_LINUX) ++#elif defined(USE_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + #include "base/logging.h" + #include "ui/base/ime/linux/fake_input_method_context_factory.h" + #elif defined(OS_WIN) +@@ -18,7 +18,7 @@ + + namespace { + +-#if !defined(OS_CHROMEOS) && defined(USE_AURA) && defined(OS_LINUX) ++#if !defined(OS_CHROMEOS) && defined(USE_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + const ui::LinuxInputMethodContextFactory* + g_linux_input_method_context_factory_for_testing; + #endif +@@ -46,7 +46,7 @@ void ShutdownInputMethod() { + void InitializeInputMethodForTesting() { + #if defined(OS_CHROMEOS) + IMEBridge::Initialize(); +-#elif defined(USE_AURA) && defined(OS_LINUX) ++#elif defined(USE_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + if (!g_linux_input_method_context_factory_for_testing) + g_linux_input_method_context_factory_for_testing = + new FakeInputMethodContextFactory(); +@@ -65,7 +65,7 @@ void InitializeInputMethodForTesting() { + void ShutdownInputMethodForTesting() { + #if defined(OS_CHROMEOS) + IMEBridge::Shutdown(); +-#elif defined(USE_AURA) && defined(OS_LINUX) ++#elif defined(USE_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + const LinuxInputMethodContextFactory* factory = + LinuxInputMethodContextFactory::instance(); + CHECK(!factory || factory == g_linux_input_method_context_factory_for_testing) +diff --git a/src/3rdparty/chromium/ui/base/resource/data_pack.cc b/src/3rdparty/chromium/ui/base/resource/data_pack.cc +index 618204d..2545e14 100644 +--- a/src/3rdparty/chromium/ui/base/resource/data_pack.cc ++++ b/src/3rdparty/chromium/ui/base/resource/data_pack.cc +@@ -165,16 +165,42 @@ bool MmapHasGzipHeader(const base::MemoryMappedFile* mmap) { + return header_status == net::GZipHeader::COMPLETE_HEADER; + } + ++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 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 uint16le_t; ++typedef byteswapped_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(void_key); + const Entry* entry = reinterpret_cast(void_entry); + return key - entry->resource_id; +@@ -182,10 +208,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(void_key); + const Alias* entry = reinterpret_cast(void_entry); + return key - entry->resource_id; +@@ -322,7 +349,7 @@ bool DataPack::LoadImpl(std::unique_ptr data_source) { + // Parse the version and check for truncated header. + uint32_t version = 0; + if (data_length > sizeof(version)) +- version = reinterpret_cast(data)[0]; ++ version = reinterpret_cast(data)[0]; + size_t header_length = + version == kFileFormatV4 ? kHeaderLengthV4 : kHeaderLengthV5; + if (version == 0 || data_length < header_length) { +@@ -333,14 +360,14 @@ bool DataPack::LoadImpl(std::unique_ptr data_source) { + + // Parse the header of the file. + if (version == kFileFormatV4) { +- resource_count_ = reinterpret_cast(data)[1]; ++ resource_count_ = reinterpret_cast(data)[1]; + alias_count_ = 0; + text_encoding_type_ = static_cast(data[8]); + } else if (version == kFileFormatV5) { + // Version 5 added the alias table and changed the header format. + text_encoding_type_ = static_cast(data[4]); +- resource_count_ = reinterpret_cast(data)[4]; +- alias_count_ = reinterpret_cast(data)[5]; ++ resource_count_ = reinterpret_cast(data)[4]; ++ alias_count_ = reinterpret_cast(data)[5]; + } else { + LOG(ERROR) << "Bad data pack version: got " << version << ", expected " + << kFileFormatV4 << " or " << kFileFormatV5; +@@ -420,12 +447,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; +@@ -491,9 +512,6 @@ void DataPack::CheckForDuplicateResources( + bool DataPack::WritePack(const base::FilePath& path, + const std::map& 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 +@@ -511,7 +529,7 @@ bool DataPack::WritePack(const base::FilePath& path, + if (!file.valid()) + return false; + +- uint32_t encoding = static_cast(text_encoding_type); ++ uint32le_t encoding = static_cast(text_encoding_type); + + // Build a list of final resource aliases, and an alias map at the same time. + std::vector resource_ids; +@@ -538,13 +556,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(aliases.size()); +- const uint16_t entry_count = static_cast(resource_ids.size()); ++ const uint16le_t alias_count = static_cast(aliases.size()); ++ const uint16le_t entry_count = static_cast(resource_ids.size()); + DCHECK_EQ(static_cast(entry_count) + static_cast(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)); + +@@ -552,8 +571,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(); +@@ -561,13 +580,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& alias : aliases) { ++ for (const std::pair& alias : aliases) { + file.Write(&alias, sizeof(alias)); + } + +diff --git a/src/3rdparty/chromium/ui/base/resource/resource_bundle.cc b/src/3rdparty/chromium/ui/base/resource/resource_bundle.cc +index f855988..8c7cbd9 100644 +--- a/src/3rdparty/chromium/ui/base/resource/resource_bundle.cc ++++ b/src/3rdparty/chromium/ui/base/resource/resource_bundle.cc +@@ -830,7 +830,7 @@ void ResourceBundle::ReloadFonts() { + } + + ScaleFactor ResourceBundle::GetMaxScaleFactor() const { +-#if defined(OS_WIN) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_HAIKU) + return max_scale_factor_; + #else + return GetSupportedScaleFactors().back(); +@@ -883,7 +883,7 @@ void ResourceBundle::InitSharedInstance(Delegate* delegate) { + // On platforms other than iOS, 100P is always a supported scale factor. + // For Windows we have a separate case in this function. + supported_scale_factors.push_back(SCALE_FACTOR_100P); +-#if defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_WIN) ++#if defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_WIN) || defined(OS_HAIKU) + supported_scale_factors.push_back(SCALE_FACTOR_200P); + #endif + #endif +diff --git a/src/3rdparty/chromium/ui/base/ui_base_features.cc b/src/3rdparty/chromium/ui/base/ui_base_features.cc +index f81a6d8..f0f036a 100644 +--- a/src/3rdparty/chromium/ui/base/ui_base_features.cc ++++ b/src/3rdparty/chromium/ui/base/ui_base_features.cc +@@ -121,7 +121,7 @@ const base::Feature kPrecisionTouchpadLogging{ + "PrecisionTouchpadLogging", base::FEATURE_DISABLED_BY_DEFAULT}; + #endif // defined(OS_WIN) + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + // Enables stylus appearing as touch when in contact with digitizer. + const base::Feature kDirectManipulationStylus = { + "DirectManipulationStylus", +@@ -131,7 +131,7 @@ const base::Feature kDirectManipulationStylus = { + base::FEATURE_DISABLED_BY_DEFAULT + #endif + }; +-#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + + // Enables forced colors mode for web content. + const base::Feature kForcedColors{"ForcedColors", +@@ -157,7 +157,7 @@ bool IsEyeDropperEnabled() { + // crbug.com/1012106 for the Windows launch bug, and crbug.com/1012108 for the + // Mac launch bug. + const base::Feature kFormControlsRefresh = {"FormControlsRefresh", +-#if defined(OS_WIN) || defined(OS_CHROMEOS) || defined(OS_LINUX) || \ ++#if defined(OS_WIN) || defined(OS_CHROMEOS) || defined(OS_LINUX) || defined(OS_HAIKU) || \ + defined(OS_MACOSX) + base::FEATURE_ENABLED_BY_DEFAULT + #else +diff --git a/src/3rdparty/chromium/ui/base/ui_base_features.h b/src/3rdparty/chromium/ui/base/ui_base_features.h +index d1c07ab..50f9dc9 100644 +--- a/src/3rdparty/chromium/ui/base/ui_base_features.h ++++ b/src/3rdparty/chromium/ui/base/ui_base_features.h +@@ -58,10 +58,10 @@ COMPONENT_EXPORT(UI_BASE_FEATURES) extern const base::Feature kTSFImeSupport; + COMPONENT_EXPORT(UI_BASE_FEATURES) bool IsUsingWMPointerForTouch(); + #endif // defined(OS_WIN) + +-#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + COMPONENT_EXPORT(UI_BASE_FEATURES) + extern const base::Feature kDirectManipulationStylus; +-#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) ++#endif // defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX) || defined(OS_HAIKU) + + // Used to enable forced colors mode for web content. + COMPONENT_EXPORT(UI_BASE_FEATURES) extern const base::Feature kForcedColors; +diff --git a/src/3rdparty/chromium/ui/base/webui/web_ui_util.cc b/src/3rdparty/chromium/ui/base/webui/web_ui_util.cc +index 6b6ea2d..dd8a66c 100644 +--- a/src/3rdparty/chromium/ui/base/webui/web_ui_util.cc ++++ b/src/3rdparty/chromium/ui/base/webui/web_ui_util.cc +@@ -236,7 +236,7 @@ std::string GetFontFamily() { + + // TODO(dnicoara) Remove Ozone check when PlatformFont support is introduced + // into Ozone: crbug.com/320050 +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(USE_OZONE) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) && !defined(USE_OZONE) + font_family = ui::ResourceBundle::GetSharedInstance().GetFont( + ui::ResourceBundle::BaseFont).GetFontName() + ", " + font_family; + #endif +diff --git a/src/3rdparty/chromium/ui/base/x/x11_shm_image_pool.cc b/src/3rdparty/chromium/ui/base/x/x11_shm_image_pool.cc +index 4719fbf..ebb0f76 100644 +--- a/src/3rdparty/chromium/ui/base/x/x11_shm_image_pool.cc ++++ b/src/3rdparty/chromium/ui/base/x/x11_shm_image_pool.cc +@@ -16,6 +16,7 @@ + #include "base/environment.h" + #include "base/location.h" + #include "base/strings/string_util.h" ++#include "base/system/sys_info.h" + #include "base/threading/thread_task_runner_handle.h" + #include "build/build_config.h" + #include "net/base/url_util.h" +@@ -44,10 +45,14 @@ constexpr float kShmResizeShrinkThreshold = + 1.0f / (kShmResizeThreshold * kShmResizeThreshold); + + std::size_t MaxShmSegmentSizeImpl() { ++#if defined(OS_HAIKU) ++ return base::SysInfo::MaxSharedMemorySize(); ++#else + struct shminfo info; + if (shmctl(0, IPC_INFO, reinterpret_cast(&info)) == -1) + return 0; + return info.shmmax; ++#endif + } + + std::size_t MaxShmSegmentSize() { +@@ -201,7 +206,7 @@ bool XShmImagePool::Resize(const gfx::Size& pixel_size) { + shmctl(state.shminfo_.shmid, IPC_RMID, nullptr); + return false; + } +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // On Linux, a shmid can still be attached after IPC_RMID if otherwise + // kept alive. Detach before XShmAttach to prevent a memory leak in case + // the process dies. +@@ -211,7 +216,7 @@ bool XShmImagePool::Resize(const gfx::Size& pixel_size) { + if (!XShmAttach(display_, &state.shminfo_)) + return false; + state.shmem_attached_to_server_ = true; +-#if !defined(OS_LINUX) ++#if (!defined(OS_LINUX) && !defined(OS_HAIKU)) + // The Linux-specific shmctl behavior above may not be portable, so we're + // forced to do IPC_RMID after the server has attached to the segment. + // XShmAttach is asynchronous, so we must also sync. +diff --git a/src/3rdparty/chromium/ui/events/devices/x11/device_data_manager_x11.cc b/src/3rdparty/chromium/ui/events/devices/x11/device_data_manager_x11.cc +index 91abd2b..4d1fa50 100644 +--- a/src/3rdparty/chromium/ui/events/devices/x11/device_data_manager_x11.cc ++++ b/src/3rdparty/chromium/ui/events/devices/x11/device_data_manager_x11.cc +@@ -826,6 +826,8 @@ void DeviceDataManagerX11::SetDisabledKeyboardAllowedKeys( + } + + void DeviceDataManagerX11::DisableDevice(int deviceid) { ++ NOTIMPLEMENTED(); ++#if !defined(OS_HAIKU) + blocked_devices_.set(deviceid, true); + // TODO(rsadam@): Support blocking touchscreen devices. + std::vector keyboards = GetKeyboardDevices(); +@@ -836,6 +838,7 @@ void DeviceDataManagerX11::DisableDevice(int deviceid) { + keyboards.erase(it); + DeviceDataManager::OnKeyboardDevicesUpdated(keyboards); + } ++#endif + } + + void DeviceDataManagerX11::EnableDevice(int deviceid) { +diff --git a/src/3rdparty/chromium/ui/events/event_switches.cc b/src/3rdparty/chromium/ui/events/event_switches.cc +index e02e816..775f856 100644 +--- a/src/3rdparty/chromium/ui/events/event_switches.cc ++++ b/src/3rdparty/chromium/ui/events/event_switches.cc +@@ -14,7 +14,7 @@ namespace switches { + const char kCompensateForUnstablePinchZoom[] = + "compensate-for-unstable-pinch-zoom"; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_FREEBSD) + // Tells chrome to interpret events from these devices as touch events. Only + // available with XInput 2 (i.e. X server 1.8 or above). The id's of the + // devices can be retrieved from 'xinput list'. +diff --git a/src/3rdparty/chromium/ui/events/event_switches.h b/src/3rdparty/chromium/ui/events/event_switches.h +index 7b39b66..351cbbb 100644 +--- a/src/3rdparty/chromium/ui/events/event_switches.h ++++ b/src/3rdparty/chromium/ui/events/event_switches.h +@@ -13,7 +13,7 @@ namespace switches { + + EVENTS_BASE_EXPORT extern const char kCompensateForUnstablePinchZoom[]; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_FREEBSD) + EVENTS_BASE_EXPORT extern const char kTouchDevices[]; + EVENTS_BASE_EXPORT extern const char kPenDevices[]; + #endif +diff --git a/src/3rdparty/chromium/ui/gfx/canvas_skia.cc b/src/3rdparty/chromium/ui/gfx/canvas_skia.cc +index 53522c1..7e3c3e9 100644 +--- a/src/3rdparty/chromium/ui/gfx/canvas_skia.cc ++++ b/src/3rdparty/chromium/ui/gfx/canvas_skia.cc +@@ -206,7 +206,7 @@ void Canvas::DrawStringRectWithFlags(const base::string16& text, + Range range = StripAcceleratorChars(flags, &adjusted_text); + bool elide_text = ((flags & NO_ELLIPSIS) == 0); + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // On Linux, eliding really means fading the end of the string. But only + // for LTR text. RTL text is still elided (on the left) with "...". + if (elide_text) { +diff --git a/src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc b/src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc +index fe91867..be26fa2 100644 +--- a/src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc ++++ b/src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc +@@ -207,6 +207,7 @@ bool JPEGCodec::Decode(const unsigned char* input, size_t input_size, + case JCS_GRAYSCALE: + case JCS_RGB: + case JCS_YCbCr: ++#ifdef JCS_EXTENSIONS + // 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 +@@ -223,6 +224,9 @@ bool JPEGCodec::Decode(const unsigned char* input, size_t input_size, + NOTREACHED() << "Invalid pixel format"; + return false; + } ++#else ++ cinfo.out_color_space = JCS_RGB; ++#endif + break; + case JCS_CMYK: + case JCS_YCCK: +diff --git a/src/3rdparty/chromium/ui/gfx/codec/png_codec.cc b/src/3rdparty/chromium/ui/gfx/codec/png_codec.cc +index f2176e9..d44b769 100644 +--- a/src/3rdparty/chromium/ui/gfx/codec/png_codec.cc ++++ b/src/3rdparty/chromium/ui/gfx/codec/png_codec.cc +@@ -169,6 +169,10 @@ void DecodeInfoCallback(png_struct* png_ptr, png_info* info_ptr) { + 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* info_ptr) { + 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; +diff --git a/src/3rdparty/chromium/ui/gfx/codec/png_codec.h b/src/3rdparty/chromium/ui/gfx/codec/png_codec.h +index dc55eac..bb9c4f6 100644 +--- a/src/3rdparty/chromium/ui/gfx/codec/png_codec.h ++++ b/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 +diff --git a/src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc b/src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc +index 260f7c9..b949b3e 100644 +--- a/src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc ++++ b/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)); + } + } + } +diff --git a/src/3rdparty/chromium/ui/gfx/color_analysis.cc b/src/3rdparty/chromium/ui/gfx/color_analysis.cc +index 5ecc566..3fb4c8f 100644 +--- a/src/3rdparty/chromium/ui/gfx/color_analysis.cc ++++ b/src/3rdparty/chromium/ui/gfx/color_analysis.cc +@@ -18,6 +18,7 @@ + #include "base/bind.h" + #include "base/callback.h" + #include "base/logging.h" ++#include "base/sys_byteorder.h" + #include "base/numerics/ranges.h" + #include "third_party/skia/include/core/SkBitmap.h" + #include "third_party/skia/include/core/SkUnPreMultiply.h" +@@ -438,10 +439,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; +@@ -459,7 +467,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, +@@ -482,10 +489,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data, + 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) +@@ -534,10 +548,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data, + 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; +@@ -615,8 +636,12 @@ SkColor CalculateKMeanColorOfPNG(scoped_refptr png, + + 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); + } +diff --git a/src/3rdparty/chromium/ui/gfx/font_fallback_linux.cc b/src/3rdparty/chromium/ui/gfx/font_fallback_linux.cc +index d9138ab..ba0721e 100644 +--- a/src/3rdparty/chromium/ui/gfx/font_fallback_linux.cc ++++ b/src/3rdparty/chromium/ui/gfx/font_fallback_linux.cc +@@ -24,6 +24,10 @@ + #include "ui/gfx/linux/fontconfig_util.h" + #include "ui/gfx/platform_font.h" + ++#if defined(OS_HAIKU) ++# include ++#endif ++ + namespace gfx { + + namespace { +diff --git a/src/3rdparty/chromium/ui/gfx/font_list.cc b/src/3rdparty/chromium/ui/gfx/font_list.cc +index 5cb2b22..a054d7b 100644 +--- a/src/3rdparty/chromium/ui/gfx/font_list.cc ++++ b/src/3rdparty/chromium/ui/gfx/font_list.cc +@@ -24,7 +24,7 @@ base::LazyInstance>::Leaky g_default_impl = + bool g_default_impl_initialized = false; + + bool IsFontFamilyAvailable(const std::string& family, SkFontMgr* fontManager) { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + return !!fontManager->legacyMakeTypeface(family.c_str(), SkFontStyle()); + #else + sk_sp set(fontManager->matchFamily(family.c_str())); +diff --git a/src/3rdparty/chromium/ui/gfx/font_util.cc b/src/3rdparty/chromium/ui/gfx/font_util.cc +index 6b56f5e..08c603a 100644 +--- a/src/3rdparty/chromium/ui/gfx/font_util.cc ++++ b/src/3rdparty/chromium/ui/gfx/font_util.cc +@@ -6,7 +6,7 @@ + + #include "build/build_config.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include + #include "ui/gfx/linux/fontconfig_util.h" + #endif +@@ -24,11 +24,11 @@ void InitializeFonts() { + // background (resources have not yet been granted to cast) since it prevents + // the long delay the user would have seen on first rendering. + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Ensures the config is created on this thread. + FcConfig* config = GetGlobalFontConfig(); + DCHECK(config); +-#endif // OS_LINUX ++#endif // OS_LINUX || OS_HAIKU + + #if defined(OS_WIN) + gfx::win::InitializeDirectWrite(); +diff --git a/src/3rdparty/chromium/ui/gfx/gpu_memory_buffer.cc b/src/3rdparty/chromium/ui/gfx/gpu_memory_buffer.cc +index 3df966f..7a75e06 100644 +--- a/src/3rdparty/chromium/ui/gfx/gpu_memory_buffer.cc ++++ b/src/3rdparty/chromium/ui/gfx/gpu_memory_buffer.cc +@@ -34,7 +34,7 @@ GpuMemoryBufferHandle GpuMemoryBufferHandle::Clone() const { + handle.region = region.Duplicate(); + handle.offset = offset; + handle.stride = stride; +-#if defined(OS_LINUX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + handle.native_pixmap_handle = CloneHandleForIPC(native_pixmap_handle); + #elif defined(OS_MACOSX) && !defined(OS_IOS) + NOTIMPLEMENTED(); +diff --git a/src/3rdparty/chromium/ui/gfx/ipc/gfx_param_traits_macros.h b/src/3rdparty/chromium/ui/gfx/ipc/gfx_param_traits_macros.h +index a75e96c..1639d10 100644 +--- a/src/3rdparty/chromium/ui/gfx/ipc/gfx_param_traits_macros.h ++++ b/src/3rdparty/chromium/ui/gfx/ipc/gfx_param_traits_macros.h +@@ -18,7 +18,7 @@ + #include "ui/gfx/selection_bound.h" + #include "ui/gfx/swap_result.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + #include "ui/gfx/native_pixmap_handle.h" + #endif + +@@ -51,7 +51,7 @@ IPC_STRUCT_TRAITS_BEGIN(gfx::GpuMemoryBufferHandle) + IPC_STRUCT_TRAITS_MEMBER(region) + IPC_STRUCT_TRAITS_MEMBER(offset) + IPC_STRUCT_TRAITS_MEMBER(stride) +-#if defined(OS_LINUX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + IPC_STRUCT_TRAITS_MEMBER(native_pixmap_handle) + #elif defined(OS_MACOSX) + IPC_STRUCT_TRAITS_MEMBER(mach_port) +@@ -66,12 +66,12 @@ IPC_STRUCT_TRAITS_BEGIN(gfx::GpuMemoryBufferId) + IPC_STRUCT_TRAITS_MEMBER(id) + IPC_STRUCT_TRAITS_END() + +-#if defined(OS_LINUX) || defined(OS_FUCHSIA) ++#if defined(OS_LINUX) || defined(OS_FUCHSIA) || defined(OS_HAIKU) + IPC_STRUCT_TRAITS_BEGIN(gfx::NativePixmapPlane) + IPC_STRUCT_TRAITS_MEMBER(stride) + IPC_STRUCT_TRAITS_MEMBER(offset) + IPC_STRUCT_TRAITS_MEMBER(size) +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + IPC_STRUCT_TRAITS_MEMBER(fd) + #elif defined(OS_FUCHSIA) + IPC_STRUCT_TRAITS_MEMBER(vmo) +@@ -80,7 +80,7 @@ IPC_STRUCT_TRAITS_END() + + IPC_STRUCT_TRAITS_BEGIN(gfx::NativePixmapHandle) + IPC_STRUCT_TRAITS_MEMBER(planes) +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + IPC_STRUCT_TRAITS_MEMBER(modifier) + #endif + #if defined(OS_FUCHSIA) +diff --git a/src/3rdparty/chromium/ui/gfx/linux/client_native_pixmap_dmabuf.cc b/src/3rdparty/chromium/ui/gfx/linux/client_native_pixmap_dmabuf.cc +index 2ba91d1..b8c04e9 100644 +--- a/src/3rdparty/chromium/ui/gfx/linux/client_native_pixmap_dmabuf.cc ++++ b/src/3rdparty/chromium/ui/gfx/linux/client_native_pixmap_dmabuf.cc +@@ -5,7 +5,9 @@ + #include "ui/gfx/linux/client_native_pixmap_dmabuf.h" + + #include ++#if !defined(__FreeBSD__) + #include ++#endif + #include + #include + #include +@@ -26,11 +28,7 @@ + #include "ui/gfx/buffer_format_util.h" + #include "ui/gfx/switches.h" + +-#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 11, 0) +-#include +-#else +-#include +- ++#if defined(__FreeBSD__) + struct dma_buf_sync { + __u64 flags; + }; +diff --git a/src/3rdparty/chromium/ui/gfx/mojom/buffer_types_mojom_traits.cc b/src/3rdparty/chromium/ui/gfx/mojom/buffer_types_mojom_traits.cc +index 3bf27b7..93450bb 100644 +--- a/src/3rdparty/chromium/ui/gfx/mojom/buffer_types_mojom_traits.cc ++++ b/src/3rdparty/chromium/ui/gfx/mojom/buffer_types_mojom_traits.cc +@@ -33,7 +33,7 @@ gfx::mojom::GpuMemoryBufferPlatformHandlePtr StructTraits< + return gfx::mojom::GpuMemoryBufferPlatformHandle::NewSharedMemoryHandle( + std::move(handle.region)); + case gfx::NATIVE_PIXMAP: +-#if defined(OS_LINUX) || defined(USE_OZONE) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(USE_OZONE) + return gfx::mojom::GpuMemoryBufferPlatformHandle::NewNativePixmapHandle( + std::move(handle.native_pixmap_handle)); + #else +@@ -109,7 +109,7 @@ bool StructTraitstype = gfx::SHARED_MEMORY_BUFFER; + out->region = std::move(platform_handle->get_shared_memory_handle()); + return true; +-#if defined(OS_LINUX) || defined(USE_OZONE) ++#if defined(OS_LINUX) || defined(OS_HAIKU) || defined(USE_OZONE) + case gfx::mojom::GpuMemoryBufferPlatformHandleDataView::Tag:: + NATIVE_PIXMAP_HANDLE: + out->type = gfx::NATIVE_PIXMAP; +diff --git a/src/3rdparty/chromium/ui/gfx/render_text.cc b/src/3rdparty/chromium/ui/gfx/render_text.cc +index 7d5fb0c..f21c99b 100644 +--- a/src/3rdparty/chromium/ui/gfx/render_text.cc ++++ b/src/3rdparty/chromium/ui/gfx/render_text.cc +@@ -1167,32 +1167,33 @@ void RenderText::SetDisplayOffset(int horizontal_offset) { + const int extra_content = GetContentWidth() - display_rect_.width(); + const int cursor_width = cursor_enabled_ ? 1 : 0; + +- int min_offset = 0; +- int max_offset = 0; ++ // avoid collisions with vm_map.h on FreeBSD --cmt ++ int _min_offset = 0; ++ int _max_offset = 0; + if (extra_content > 0) { + switch (GetCurrentHorizontalAlignment()) { + case ALIGN_LEFT: +- min_offset = -extra_content; ++ _min_offset = -extra_content; + break; + case ALIGN_RIGHT: +- max_offset = extra_content; ++ _max_offset = extra_content; + break; + case ALIGN_CENTER: + // The extra space reserved for cursor at the end of the text is ignored + // when centering text. So, to calculate the valid range for offset, we + // exclude that extra space, calculate the range, and add it back to the + // range (if cursor is enabled). +- min_offset = -(extra_content - cursor_width + 1) / 2 - cursor_width; +- max_offset = (extra_content - cursor_width) / 2; ++ _min_offset = -(extra_content - cursor_width + 1) / 2 - cursor_width; ++ _max_offset = (extra_content - cursor_width) / 2; + break; + default: + break; + } + } +- if (horizontal_offset < min_offset) +- horizontal_offset = min_offset; +- else if (horizontal_offset > max_offset) +- horizontal_offset = max_offset; ++ if (horizontal_offset < _min_offset) ++ horizontal_offset = _min_offset; ++ else if (horizontal_offset > _max_offset) ++ horizontal_offset = _max_offset; + + cached_bounds_and_offset_valid_ = true; + display_offset_.set_x(horizontal_offset); +diff --git a/src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc b/src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc +index 65f6843..8adb302 100644 +--- a/src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc ++++ b/src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc +@@ -238,7 +238,7 @@ TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapHueOnly) { + + 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++; + } + } +diff --git a/src/3rdparty/chromium/ui/gl/generate_bindings.py b/src/3rdparty/chromium/ui/gl/generate_bindings.py +index 96d52d5..9baf769 100755 +--- a/src/3rdparty/chromium/ui/gl/generate_bindings.py ++++ b/src/3rdparty/chromium/ui/gl/generate_bindings.py +@@ -2805,6 +2805,9 @@ GLX_FUNCTIONS = [ + 'arguments': + 'Display* dpy, GLXDrawable drawable, int32_t* numerator, ' + 'int32_t* denominator' }, ++{ 'return_type': '__GLXextFuncPtr', ++ 'names': ['glXGetProcAddressARB'], ++ 'arguments': 'const GLubyte* procName', }, + { 'return_type': 'void', + 'names': ['glXGetSelectedEvent'], + 'arguments': 'Display* dpy, GLXDrawable drawable, unsigned long* mask', }, +diff --git a/src/3rdparty/chromium/ui/gl/gl_bindings_api_autogen_glx.h b/src/3rdparty/chromium/ui/gl/gl_bindings_api_autogen_glx.h +index 20a78ef..0043a1d 100644 +--- a/src/3rdparty/chromium/ui/gl/gl_bindings_api_autogen_glx.h ++++ b/src/3rdparty/chromium/ui/gl/gl_bindings_api_autogen_glx.h +@@ -88,6 +88,7 @@ bool glXGetMscRateOMLFn(Display* dpy, + GLXDrawable drawable, + int32_t* numerator, + int32_t* denominator) override; ++__GLXextFuncPtr glXGetProcAddressARBFn(const GLubyte* procName) override; + void glXGetSelectedEventFn(Display* dpy, + GLXDrawable drawable, + unsigned long* mask) override; +diff --git a/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.cc b/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.cc +index 6c381f0..a202433 100644 +--- a/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.cc ++++ b/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.cc +@@ -119,6 +119,8 @@ void DriverGLX::InitializeExtensionBindings() { + + ext.b_GLX_ARB_create_context = + gfx::HasExtension(extensions, "GLX_ARB_create_context"); ++ ext.b_GLX_ARB_get_proc_address = ++ gfx::HasExtension(extensions, "GLX_ARB_get_proc_address"); + ext.b_GLX_EXT_swap_control = + gfx::HasExtension(extensions, "GLX_EXT_swap_control"); + ext.b_GLX_EXT_texture_from_pixmap = +@@ -149,6 +151,11 @@ void DriverGLX::InitializeExtensionBindings() { + GetGLProcAddress("glXCreateContextAttribsARB")); + } + ++ if (ext.b_GLX_ARB_get_proc_address) { ++ fn.glXGetProcAddressARBFn = reinterpret_cast( ++ GetGLProcAddress("glXGetProcAddressARB")); ++ } ++ + if (ext.b_GLX_SGIX_fbconfig) { + fn.glXGetFBConfigFromVisualSGIXFn = + reinterpret_cast( +@@ -350,6 +357,10 @@ bool GLXApiBase::glXGetMscRateOMLFn(Display* dpy, + return driver_->fn.glXGetMscRateOMLFn(dpy, drawable, numerator, denominator); + } + ++__GLXextFuncPtr GLXApiBase::glXGetProcAddressARBFn(const GLubyte* procName) { ++ return driver_->fn.glXGetProcAddressARBFn(procName); ++} ++ + void GLXApiBase::glXGetSelectedEventFn(Display* dpy, + GLXDrawable drawable, + unsigned long* mask) { +@@ -651,6 +662,11 @@ bool TraceGLXApi::glXGetMscRateOMLFn(Display* dpy, + return glx_api_->glXGetMscRateOMLFn(dpy, drawable, numerator, denominator); + } + ++__GLXextFuncPtr TraceGLXApi::glXGetProcAddressARBFn(const GLubyte* procName) { ++ TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetProcAddressARB") ++ return glx_api_->glXGetProcAddressARBFn(procName); ++} ++ + void TraceGLXApi::glXGetSelectedEventFn(Display* dpy, + GLXDrawable drawable, + unsigned long* mask) { +@@ -1076,6 +1092,14 @@ bool LogGLXApi::glXGetMscRateOMLFn(Display* dpy, + return result; + } + ++__GLXextFuncPtr LogGLXApi::glXGetProcAddressARBFn(const GLubyte* procName) { ++ GL_SERVICE_LOG("glXGetProcAddressARB" ++ << "(" << static_cast(procName) << ")"); ++ __GLXextFuncPtr result = glx_api_->glXGetProcAddressARBFn(procName); ++ GL_SERVICE_LOG("GL_RESULT: " << result); ++ return result; ++} ++ + void LogGLXApi::glXGetSelectedEventFn(Display* dpy, + GLXDrawable drawable, + unsigned long* mask) { +diff --git a/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.h b/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.h +index 2cd87ed..27bba93 100644 +--- a/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.h ++++ b/src/3rdparty/chromium/ui/gl/gl_bindings_autogen_glx.h +@@ -104,6 +104,8 @@ typedef bool(GL_BINDING_CALL* glXGetMscRateOMLProc)(Display* dpy, + GLXDrawable drawable, + int32_t* numerator, + int32_t* denominator); ++typedef __GLXextFuncPtr(GL_BINDING_CALL* glXGetProcAddressARBProc)( ++ const GLubyte* procName); + typedef void(GL_BINDING_CALL* glXGetSelectedEventProc)(Display* dpy, + GLXDrawable drawable, + unsigned long* mask); +@@ -166,6 +168,7 @@ typedef void(GL_BINDING_CALL* glXWaitXProc)(void); + + struct ExtensionsGLX { + bool b_GLX_ARB_create_context; ++ bool b_GLX_ARB_get_proc_address; + bool b_GLX_EXT_swap_control; + bool b_GLX_EXT_texture_from_pixmap; + bool b_GLX_MESA_copy_sub_buffer; +@@ -203,6 +206,7 @@ struct ProcsGLX { + glXGetFBConfigFromVisualSGIXProc glXGetFBConfigFromVisualSGIXFn; + glXGetFBConfigsProc glXGetFBConfigsFn; + glXGetMscRateOMLProc glXGetMscRateOMLFn; ++ glXGetProcAddressARBProc glXGetProcAddressARBFn; + glXGetSelectedEventProc glXGetSelectedEventFn; + glXGetSyncValuesOMLProc glXGetSyncValuesOMLFn; + glXGetVisualFromFBConfigProc glXGetVisualFromFBConfigFn; +@@ -310,6 +314,7 @@ class GL_EXPORT GLXApi { + GLXDrawable drawable, + int32_t* numerator, + int32_t* denominator) = 0; ++ virtual __GLXextFuncPtr glXGetProcAddressARBFn(const GLubyte* procName) = 0; + virtual void glXGetSelectedEventFn(Display* dpy, + GLXDrawable drawable, + unsigned long* mask) = 0; +@@ -394,6 +399,7 @@ class GL_EXPORT GLXApi { + ::gl::g_current_glx_context->glXGetFBConfigFromVisualSGIXFn + #define glXGetFBConfigs ::gl::g_current_glx_context->glXGetFBConfigsFn + #define glXGetMscRateOML ::gl::g_current_glx_context->glXGetMscRateOMLFn ++#define glXGetProcAddressARB ::gl::g_current_glx_context->glXGetProcAddressARBFn + #define glXGetSelectedEvent ::gl::g_current_glx_context->glXGetSelectedEventFn + #define glXGetSyncValuesOML ::gl::g_current_glx_context->glXGetSyncValuesOMLFn + #define glXGetVisualFromFBConfig \ +diff --git a/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.cc b/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.cc +index 79359e7..3bb6386 100644 +--- a/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.cc ++++ b/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.cc +@@ -11,7 +11,7 @@ + #include "base/trace_event/trace_event.h" + #include "build/build_config.h" + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // These constants define a reasonable range for a calculated refresh interval. + // Calculating refreshes out of this range will be considered a fatal error. + const int64_t kMinVsyncIntervalUs = base::Time::kMicrosecondsPerSecond / 400; +@@ -26,7 +26,7 @@ const double kRelativeIntervalDifferenceThreshold = 0.05; + namespace gl { + + SyncControlVSyncProvider::SyncControlVSyncProvider() : gfx::VSyncProvider() { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // On platforms where we can't get an accurate reading on the refresh + // rate we fall back to the assumption that we're displaying 60 frames + // per second. +@@ -48,7 +48,7 @@ bool SyncControlVSyncProvider::GetVSyncParametersIfAvailable( + base::TimeTicks* timebase_out, + base::TimeDelta* interval_out) { + TRACE_EVENT0("gpu", "SyncControlVSyncProvider::GetVSyncParameters"); +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // The actual clock used for the system time returned by glXGetSyncValuesOML + // is unspecified. In practice, the clock used is likely to be either + // CLOCK_REALTIME or CLOCK_MONOTONIC, so we compare the returned time to the +@@ -156,11 +156,11 @@ bool SyncControlVSyncProvider::GetVSyncParametersIfAvailable( + return true; + #else + return false; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + } + + bool SyncControlVSyncProvider::SupportGetVSyncParametersIfAvailable() const { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + return true; + #else + return false; +diff --git a/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.h b/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.h +index d958a2b..acd4756 100644 +--- a/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.h ++++ b/src/3rdparty/chromium/ui/gl/sync_control_vsync_provider.h +@@ -26,11 +26,11 @@ class SyncControlVSyncProvider : public gfx::VSyncProvider { + bool SupportGetVSyncParametersIfAvailable() const override; + + static constexpr bool IsSupported() { +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + return true; + #else + return false; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + } + + protected: +@@ -41,7 +41,7 @@ class SyncControlVSyncProvider : public gfx::VSyncProvider { + virtual bool GetMscRate(int32_t* numerator, int32_t* denominator) = 0; + + private: +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + base::TimeTicks last_timebase_; + uint64_t last_media_stream_counter_ = 0; + base::TimeDelta last_good_interval_; +@@ -52,7 +52,7 @@ class SyncControlVSyncProvider : public gfx::VSyncProvider { + // from configuration change (monitor reconfiguration, moving windows + // between monitors, suspend and resume, etc.). + base::queue last_computed_intervals_; +-#endif // defined(OS_LINUX) ++#endif // defined(OS_LINUX) || defined(OS_HAIKU) + + DISALLOW_COPY_AND_ASSIGN(SyncControlVSyncProvider); + }; +diff --git a/src/3rdparty/chromium/ui/message_center/public/cpp/message_center_constants.h b/src/3rdparty/chromium/ui/message_center/public/cpp/message_center_constants.h +index 5996883..fcf8234 100644 +--- a/src/3rdparty/chromium/ui/message_center/public/cpp/message_center_constants.h ++++ b/src/3rdparty/chromium/ui/message_center/public/cpp/message_center_constants.h +@@ -109,7 +109,7 @@ const int kButtonHorizontalPadding = 16; // In DIPs. + const int kButtonIconTopPadding = 11; // In DIPs. + const int kButtonIconToTitlePadding = 16; // In DIPs. + +-#if !defined(OS_LINUX) || defined(USE_AURA) ++#if (!defined(OS_LINUX) && !defined(OS_HAIKU)) || defined(USE_AURA) + constexpr SkColor kButtonSeparatorColor = SkColorSetRGB(234, 234, 234); + constexpr SkColor kHoveredButtonBackgroundColor = SkColorSetRGB(243, 243, 243); + #endif +diff --git a/src/3rdparty/chromium/ui/message_center/views/message_popup_view.cc b/src/3rdparty/chromium/ui/message_center/views/message_popup_view.cc +index bd6fac8..2306451 100644 +--- a/src/3rdparty/chromium/ui/message_center/views/message_popup_view.cc ++++ b/src/3rdparty/chromium/ui/message_center/views/message_popup_view.cc +@@ -101,7 +101,7 @@ void MessagePopupView::AutoCollapse() { + void MessagePopupView::Show() { + views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP); + params.z_order = ui::ZOrderLevel::kFloatingWindow; +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + // Make the widget explicitly activatable as TYPE_POPUP is not activatable by + // default but we need focus for the inline reply textarea. + params.activatable = views::Widget::InitParams::ACTIVATABLE_YES; +diff --git a/src/3rdparty/chromium/ui/native_theme/native_theme.h b/src/3rdparty/chromium/ui/native_theme/native_theme.h +index 8c60a3f..fc5a00b 100644 +--- a/src/3rdparty/chromium/ui/native_theme/native_theme.h ++++ b/src/3rdparty/chromium/ui/native_theme/native_theme.h +@@ -51,7 +51,7 @@ class NATIVE_THEME_EXPORT NativeTheme { + // The part to be painted / sized. + enum Part { + kCheckbox, +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + kFrameTopArea, + #endif + kInnerSpinButton, +diff --git a/src/3rdparty/chromium/ui/native_theme/native_theme_base.cc b/src/3rdparty/chromium/ui/native_theme/native_theme_base.cc +index c65f826..7325b7e 100644 +--- a/src/3rdparty/chromium/ui/native_theme/native_theme_base.cc ++++ b/src/3rdparty/chromium/ui/native_theme/native_theme_base.cc +@@ -254,7 +254,7 @@ void NativeThemeBase::Paint(cc::PaintCanvas* canvas, + case kCheckbox: + PaintCheckbox(canvas, state, rect, extra.button, color_scheme); + break; +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + case kFrameTopArea: + PaintFrameTopArea(canvas, state, rect, extra.frame_top_area, + color_scheme); +diff --git a/src/3rdparty/chromium/ui/platform_window/platform_window_init_properties.h b/src/3rdparty/chromium/ui/platform_window/platform_window_init_properties.h +index d1a5cc0..cfec19a 100644 +--- a/src/3rdparty/chromium/ui/platform_window/platform_window_init_properties.h ++++ b/src/3rdparty/chromium/ui/platform_window/platform_window_init_properties.h +@@ -41,7 +41,7 @@ enum class PlatformWindowOpacity { + + class WorkspaceExtensionDelegate; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + class X11ExtensionDelegate; + #endif + +@@ -82,7 +82,7 @@ struct COMPONENT_EXPORT(PLATFORM_WINDOW) PlatformWindowInitProperties { + + WorkspaceExtensionDelegate* workspace_extension_delegate = nullptr; + +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + bool prefer_dark_theme = false; + gfx::ImageSkia* icon = nullptr; + base::Optional background_color; +diff --git a/src/3rdparty/chromium/ui/strings/app_locale_settings.grd b/src/3rdparty/chromium/ui/strings/app_locale_settings.grd +index c07b66b..374670f 100644 +--- a/src/3rdparty/chromium/ui/strings/app_locale_settings.grd ++++ b/src/3rdparty/chromium/ui/strings/app_locale_settings.grd +@@ -216,7 +216,7 @@ + 75% + + +- ++ + + +diff --git a/src/3rdparty/chromium/ui/views/bubble/bubble_dialog_delegate_view.cc b/src/3rdparty/chromium/ui/views/bubble/bubble_dialog_delegate_view.cc +index 308adac..dc87438 100644 +--- a/src/3rdparty/chromium/ui/views/bubble/bubble_dialog_delegate_view.cc ++++ b/src/3rdparty/chromium/ui/views/bubble/bubble_dialog_delegate_view.cc +@@ -171,7 +171,7 @@ Widget* BubbleDialogDelegateView::CreateBubble( + bubble_delegate->Init(); + Widget* bubble_widget = CreateBubbleWidget(bubble_delegate); + +-#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_MACOSX) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_MACOSX) || defined(OS_HAIKU) + // Linux clips bubble windows that extend outside their parent window bounds. + // Mac never adjusts. + bubble_delegate->set_adjust_if_offscreen(false); +diff --git a/src/3rdparty/chromium/ui/views/controls/label.cc b/src/3rdparty/chromium/ui/views/controls/label.cc +index c15c27a..a6b5538 100644 +--- a/src/3rdparty/chromium/ui/views/controls/label.cc ++++ b/src/3rdparty/chromium/ui/views/controls/label.cc +@@ -695,7 +695,7 @@ bool Label::OnMousePressed(const ui::MouseEvent& event) { + GetFocusManager()->SetFocusedView(this); + } + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + if (event.IsOnlyMiddleMouseButton() && GetFocusManager() && !had_focus) + GetFocusManager()->SetFocusedView(this); + #endif +@@ -881,7 +881,7 @@ bool Label::PasteSelectionClipboard() { + } + + void Label::UpdateSelectionClipboard() { +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + if (!GetObscured()) { + ui::ScopedClipboardWriter(ui::ClipboardBuffer::kSelection) + .WriteText(GetSelectedText()); +diff --git a/src/3rdparty/chromium/ui/views/controls/textfield/textfield.cc b/src/3rdparty/chromium/ui/views/controls/textfield/textfield.cc +index 61b11e5..d453499 100644 +--- a/src/3rdparty/chromium/ui/views/controls/textfield/textfield.cc ++++ b/src/3rdparty/chromium/ui/views/controls/textfield/textfield.cc +@@ -62,7 +62,7 @@ + #include "base/win/win_util.h" + #endif + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_HAIKU) + #include "ui/base/ime/linux/text_edit_command_auralinux.h" + #include "ui/base/ime/linux/text_edit_key_bindings_delegate_auralinux.h" + #endif +@@ -183,14 +183,14 @@ ui::TextEditCommand GetCommandForKeyEvent(const ui::KeyEvent& event) { + #endif + return ui::TextEditCommand::DELETE_BACKWARD; + } +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Only erase by line break on Linux and ChromeOS. + if (shift) + return ui::TextEditCommand::DELETE_TO_BEGINNING_OF_LINE; + #endif + return ui::TextEditCommand::DELETE_WORD_BACKWARD; + case ui::VKEY_DELETE: +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Only erase by line break on Linux and ChromeOS. + if (shift && control) + return ui::TextEditCommand::DELETE_TO_END_OF_LINE; +@@ -258,7 +258,7 @@ bool IsControlKeyModifier(int flags) { + // Control-modified key combination, but we cannot extend it to other platforms + // as Control has different meanings and behaviors. + // https://crrev.com/2580483002/#msg46 +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + return flags & ui::EF_CONTROL_DOWN; + #else + return false; +@@ -691,7 +691,7 @@ bool Textfield::OnMousePressed(const ui::MouseEvent& event) { + #endif + } + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + if (!handled && !had_focus && event.IsOnlyMiddleMouseButton()) + RequestFocusWithPointer(ui::EventPointerType::POINTER_TYPE_MOUSE); + #endif +@@ -737,7 +737,7 @@ bool Textfield::OnKeyPressed(const ui::KeyEvent& event) { + if (!textfield) + return handled; + +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + ui::TextEditKeyBindingsDelegateAuraLinux* delegate = + ui::GetTextEditKeyBindingsDelegate(); + std::vector commands; +@@ -886,7 +886,7 @@ void Textfield::AboutToRequestFocusFromTabTraversal(bool reverse) { + } + + bool Textfield::SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) { +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + // Skip any accelerator handling that conflicts with custom keybindings. + ui::TextEditKeyBindingsDelegateAuraLinux* delegate = + ui::GetTextEditKeyBindingsDelegate(); +@@ -2146,7 +2146,7 @@ bool Textfield::PasteSelectionClipboard() { + } + + void Textfield::UpdateSelectionClipboard() { +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + if (text_input_type_ != ui::TEXT_INPUT_TYPE_PASSWORD) { + ui::ScopedClipboardWriter(ui::ClipboardBuffer::kSelection) + .WriteText(GetSelectedText()); +diff --git a/src/3rdparty/chromium/ui/views/corewm/tooltip_aura.cc b/src/3rdparty/chromium/ui/views/corewm/tooltip_aura.cc +index c115ea2..7b97c77 100644 +--- a/src/3rdparty/chromium/ui/views/corewm/tooltip_aura.cc ++++ b/src/3rdparty/chromium/ui/views/corewm/tooltip_aura.cc +@@ -46,7 +46,7 @@ constexpr int kVerticalPaddingBottom = 5; + + // TODO(varkha): Update if native widget can be transparent on Linux. + bool CanUseTranslucentTooltipWidget() { +-#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_WIN) ++#if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_WIN) || defined(OS_HAIKU) + return false; + #else + return true; +diff --git a/src/3rdparty/chromium/ui/views/examples/widget_example.cc b/src/3rdparty/chromium/ui/views/examples/widget_example.cc +index a09246a..b292d7a 100644 +--- a/src/3rdparty/chromium/ui/views/examples/widget_example.cc ++++ b/src/3rdparty/chromium/ui/views/examples/widget_example.cc +@@ -72,7 +72,7 @@ void WidgetExample::CreateExampleView(View* container) { + BuildButton(container, "Popup widget", POPUP); + BuildButton(container, "Dialog widget", DIALOG); + BuildButton(container, "Modal Dialog", MODAL_DIALOG); +-#if defined(OS_LINUX) ++#if defined(OS_LINUX) || defined(OS_HAIKU) + // Windows does not support TYPE_CONTROL top-level widgets. + BuildButton(container, "Child widget", CHILD); + #endif +diff --git a/src/3rdparty/chromium/ui/views/selection_controller.cc b/src/3rdparty/chromium/ui/views/selection_controller.cc +index 13c005d..ceed087 100644 +--- a/src/3rdparty/chromium/ui/views/selection_controller.cc ++++ b/src/3rdparty/chromium/ui/views/selection_controller.cc +@@ -23,7 +23,7 @@ SelectionController::SelectionController(SelectionControllerDelegate* delegate) + delegate_(delegate), + handles_selection_clipboard_(false) { + // On Linux, update the selection clipboard on a text selection. +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && !defined(OS_CHROMEOS) + set_handles_selection_clipboard(true); + #endif + +diff --git a/src/3rdparty/chromium/ui/views/style/platform_style.cc b/src/3rdparty/chromium/ui/views/style/platform_style.cc +index a5f91b0..279c4ee 100644 +--- a/src/3rdparty/chromium/ui/views/style/platform_style.cc ++++ b/src/3rdparty/chromium/ui/views/style/platform_style.cc +@@ -74,7 +74,7 @@ gfx::Range PlatformStyle::RangeToDeleteBackwards(const base::string16& text, + + #endif // OS_MACOSX + +-#if !BUILDFLAG(ENABLE_DESKTOP_AURA) || !defined(OS_LINUX) ++#if !BUILDFLAG(ENABLE_DESKTOP_AURA) || !(defined(OS_LINUX) || defined(OS_HAIKU)) + // static + std::unique_ptr PlatformStyle::CreateThemedLabelButtonBorder( + LabelButton* button) { +diff --git a/src/3rdparty/chromium/ui/views/views_delegate.cc b/src/3rdparty/chromium/ui/views/views_delegate.cc +index e000750..3816358 100644 +--- a/src/3rdparty/chromium/ui/views/views_delegate.cc ++++ b/src/3rdparty/chromium/ui/views/views_delegate.cc +@@ -85,7 +85,7 @@ HICON ViewsDelegate::GetSmallWindowIcon() const { + bool ViewsDelegate::IsWindowInMetro(gfx::NativeWindow window) const { + return false; + } +-#elif defined(OS_LINUX) && BUILDFLAG(ENABLE_DESKTOP_AURA) ++#elif (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(ENABLE_DESKTOP_AURA) + gfx::ImageSkia* ViewsDelegate::GetDefaultWindowIcon() const { + return nullptr; + } +diff --git a/src/3rdparty/chromium/ui/views/views_delegate.h b/src/3rdparty/chromium/ui/views/views_delegate.h +index 23b538a..a2830e4 100644 +--- a/src/3rdparty/chromium/ui/views/views_delegate.h ++++ b/src/3rdparty/chromium/ui/views/views_delegate.h +@@ -133,7 +133,7 @@ class VIEWS_EXPORT ViewsDelegate { + // Returns true if the window passed in is in the Windows 8 metro + // environment. + virtual bool IsWindowInMetro(gfx::NativeWindow window) const; +-#elif defined(OS_LINUX) && BUILDFLAG(ENABLE_DESKTOP_AURA) ++#elif (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(ENABLE_DESKTOP_AURA) + virtual gfx::ImageSkia* GetDefaultWindowIcon() const; + #endif + +diff --git a/src/3rdparty/chromium/ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc b/src/3rdparty/chromium/ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc +index f3a3175..c0d82ef 100644 +--- a/src/3rdparty/chromium/ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc ++++ b/src/3rdparty/chromium/ui/views/widget/desktop_aura/desktop_window_tree_host_platform.cc +@@ -754,7 +754,7 @@ void DesktopWindowTreeHostPlatform::AddAdditionalInitProperties( + // DesktopWindowTreeHost: + + // Linux subclasses this host and adds some Linux specific bits. +-#if !defined(OS_LINUX) ++#if !defined(OS_LINUX) && !defined(OS_HAIKU) + // static + DesktopWindowTreeHost* DesktopWindowTreeHost::Create( + internal::NativeWidgetDelegate* native_widget_delegate, +diff --git a/src/3rdparty/chromium/ui/views/widget/native_widget_aura.cc b/src/3rdparty/chromium/ui/views/widget/native_widget_aura.cc +index efd5380..e06d90f 100644 +--- a/src/3rdparty/chromium/ui/views/widget/native_widget_aura.cc ++++ b/src/3rdparty/chromium/ui/views/widget/native_widget_aura.cc +@@ -64,7 +64,7 @@ + #include "ui/views/widget/desktop_aura/desktop_window_tree_host_win.h" + #endif + +-#if BUILDFLAG(ENABLE_DESKTOP_AURA) && defined(OS_LINUX) ++#if BUILDFLAG(ENABLE_DESKTOP_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + #include "ui/views/linux_ui/linux_ui.h" + #include "ui/views/widget/desktop_aura/desktop_window_tree_host_linux.h" + #endif +@@ -1102,13 +1102,13 @@ void Widget::CloseAllSecondaryWidgets() { + EnumThreadWindows(GetCurrentThreadId(), WindowCallbackProc, 0); + #endif + +-#if BUILDFLAG(ENABLE_DESKTOP_AURA) && defined(OS_LINUX) ++#if BUILDFLAG(ENABLE_DESKTOP_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + DesktopWindowTreeHostLinux::CleanUpWindowList(CloseWindow); + #endif + } + + const ui::NativeTheme* Widget::GetNativeTheme() const { +-#if BUILDFLAG(ENABLE_DESKTOP_AURA) && defined(OS_LINUX) ++#if BUILDFLAG(ENABLE_DESKTOP_AURA) && (defined(OS_LINUX) || defined(OS_HAIKU)) + const LinuxUI* linux_ui = LinuxUI::instance(); + if (linux_ui) { + ui::NativeTheme* native_theme = +diff --git a/src/3rdparty/chromium/ui/views/window/custom_frame_view.cc b/src/3rdparty/chromium/ui/views/window/custom_frame_view.cc +index c0bc655..ad0870a 100644 +--- a/src/3rdparty/chromium/ui/views/window/custom_frame_view.cc ++++ b/src/3rdparty/chromium/ui/views/window/custom_frame_view.cc +@@ -283,7 +283,7 @@ int CustomFrameView::NonClientTopBorderHeight() const { + int CustomFrameView::CaptionButtonY() const { + // Maximized buttons start at window top so that even if their images aren't + // drawn flush with the screen edge, they still obey Fitts' Law. +-#if defined(OS_LINUX) && !defined(OS_CHROMEOS) ++#if defined(OS_LINUX) && !defined(OS_CHROMEOS) || defined(OS_HAIKU) + return FrameBorderThickness(); + #else + return frame_->IsMaximized() ? FrameBorderThickness() : kFrameShadowThickness; +diff --git a/src/3rdparty/chromium/ui/views/window/dialog_delegate.cc b/src/3rdparty/chromium/ui/views/window/dialog_delegate.cc +index 16ee382..3b734a9 100644 +--- a/src/3rdparty/chromium/ui/views/window/dialog_delegate.cc ++++ b/src/3rdparty/chromium/ui/views/window/dialog_delegate.cc +@@ -59,7 +59,7 @@ Widget* DialogDelegate::CreateDialogWidget(WidgetDelegate* delegate, + + // static + bool DialogDelegate::CanSupportCustomFrame(gfx::NativeView parent) { +-#if defined(OS_LINUX) && BUILDFLAG(ENABLE_DESKTOP_AURA) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(ENABLE_DESKTOP_AURA) + // The new style doesn't support unparented dialogs on Linux desktop. + return parent != nullptr; + #else +diff --git a/src/3rdparty/chromium/ui/views/window/frame_background.cc b/src/3rdparty/chromium/ui/views/window/frame_background.cc +index 6e8de53..3ae7ded 100644 +--- a/src/3rdparty/chromium/ui/views/window/frame_background.cc ++++ b/src/3rdparty/chromium/ui/views/window/frame_background.cc +@@ -99,7 +99,7 @@ void FrameBackground::PaintMaximized(gfx::Canvas* canvas, + const View* view) const { + // Fill the top with the frame color first so we have a constant background + // for areas not covered by the theme image. +-#if defined(OS_LINUX) && BUILDFLAG(ENABLE_DESKTOP_AURA) ++#if (defined(OS_LINUX) || defined(OS_HAIKU)) && BUILDFLAG(ENABLE_DESKTOP_AURA) + auto* native_theme = view->GetNativeTheme(); + ui::NativeTheme::ExtraParams params; + params.frame_top_area.use_custom_frame = use_custom_frame_; +diff --git a/src/3rdparty/chromium/ui/webui/resources/js/cr.js b/src/3rdparty/chromium/ui/webui/resources/js/cr.js +index fe1ef1e..4b44ea7 100644 +--- a/src/3rdparty/chromium/ui/webui/resources/js/cr.js ++++ b/src/3rdparty/chromium/ui/webui/resources/js/cr.js +@@ -431,6 +431,11 @@ var cr = cr || function(global) { + return /Mac/.test(navigator.platform); + }, + ++ /** Whether this is on *Haiku. */ ++ get isHaiku() { ++ return /Haiku/.test(navigator.userAgent); ++ }, ++ + /** Whether this is on the Windows platform or not. */ + get isWindows() { + return /Win/.test(navigator.platform); +diff --git a/src/3rdparty/chromium/ui/webui/resources/js/icon.js b/src/3rdparty/chromium/ui/webui/resources/js/icon.js +index 0d2c740..4c3e9f5 100644 +--- a/src/3rdparty/chromium/ui/webui/resources/js/icon.js ++++ b/src/3rdparty/chromium/ui/webui/resources/js/icon.js +@@ -16,7 +16,7 @@ cr.define('cr.icon', function() { + // supports SCALE_FACTOR_100P on all non-iOS platforms. + supportedScaleFactors.push(1); + } +- if (cr.isMac || cr.isChromeOS || cr.isWindows || cr.isLinux) { ++ if (cr.isMac || cr.isChromeOS || cr.isWindows || cr.isLinux || cr.isHaiku) { + // All desktop platforms support zooming which also updates the renderer's + // device scale factors (a.k.a devicePixelRatio), and these platforms have + // high DPI assets for 2x. Let the renderer pick the closest image for +diff --git a/src/3rdparty/chromium/url/url_canon_host.cc b/src/3rdparty/chromium/url/url_canon_host.cc +index 9f31547..08f417d 100644 +--- a/src/3rdparty/chromium/url/url_canon_host.cc ++++ b/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(&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. +diff --git a/src/3rdparty/chromium/url/url_canon_internal.h b/src/3rdparty/chromium/url/url_canon_internal.h +index ba8b9ee..a306dfa 100644 +--- a/src/3rdparty/chromium/url/url_canon_internal.h ++++ b/src/3rdparty/chromium/url/url_canon_internal.h +@@ -305,9 +305,9 @@ inline bool Is8BitChar(base::char16 c) { + return c <= 255; + } + +-template ++template + 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 +diff --git a/src/3rdparty/gn/util/sys_info.cc b/src/3rdparty/gn/util/sys_info.cc +index 5fefc9b..5e969c1 100644 +--- a/src/3rdparty/gn/util/sys_info.cc ++++ b/src/3rdparty/gn/util/sys_info.cc +@@ -28,6 +28,8 @@ std::string OperatingSystemArchitecture() { + arch = "x86"; + } else if (arch == "amd64") { + arch = "x86_64"; ++ } else if (arch == "arm64") { ++ arch = "aarch64"; + } else if (std::string(info.sysname) == "AIX") { + arch = "ppc64"; + } +-- +2.37.3 + + +From ff1e01e9697f7213a2caf63ebe074166ca205b96 Mon Sep 17 00:00:00 2001 +From: Jerome Duval +Date: Fri, 24 Nov 2023 18:06:38 +0100 +Subject: blink: fix WTF:internal:GetStackStart() and + GetUnderestimatedStackSize() + +this is only for beta4, we can switch later to the pthread API. + +diff --git a/src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/stack_util.cc b/src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/stack_util.cc +index e2fc0a7..6fe84a8 100644 +--- a/src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/stack_util.cc ++++ b/src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/stack_util.cc +@@ -94,8 +94,12 @@ size_t GetUnderestimatedStackSize() { + #endif + } + return pthread_get_stacksize_np(pthread_self()); +-#elif defined(OS_HAIKU) || defined(OS_WIN) && defined(COMPILER_MSVC) ++#elif defined(OS_WIN) && defined(COMPILER_MSVC) + return WTF::internal::ThreadStackSize(); ++#elif defined(OS_HAIKU) ++ thread_info threadInfo; ++ get_thread_info(find_thread(NULL), &threadInfo); ++ return (size_t)threadInfo.stack_end - (size_t)threadInfo.stack_base; + #else + #error "Stack frame size estimation not supported on this platform." + return 0; +@@ -155,7 +159,7 @@ void* GetStackStart() { + #elif defined(OS_HAIKU) + thread_info threadInfo; + get_thread_info(find_thread(NULL), &threadInfo); +- return threadInfo.stack_base; ++ return threadInfo.stack_end; + #else + #error Unsupported getStackStart on this platform. + #endif +-- +2.37.3 + + +From 02bc964b9caf16db8c4a2c95b023077d6c187398 Mon Sep 17 00:00:00 2001 +From: Jerome Duval +Date: Fri, 24 Nov 2023 18:10:13 +0100 +Subject: sqlite: new warning on gcc13 + + +diff --git a/src/3rdparty/chromium/third_party/sqlite/BUILD.gn b/src/3rdparty/chromium/third_party/sqlite/BUILD.gn +index 1b599a4..d80833c 100644 +--- a/src/3rdparty/chromium/third_party/sqlite/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/sqlite/BUILD.gn +@@ -138,12 +138,13 @@ config("sqlite_warnings") { + ] + } + } +- if (is_linux && !is_haiku) { ++ if (is_linux || is_haiku) { + cflags += [ + # SQLite doesn't believe in compiler warnings, preferring testing. + # http://www.sqlite.org/faq.html#q17 + "-Wno-int-to-pointer-cast", + "-Wno-pointer-to-int-cast", ++ "-Wreturn-local-addr" + ] + } + if (is_ios) { +-- +2.37.3 + + +From 952f26fa9900373054970dab8bac6ad758970fcc Mon Sep 17 00:00:00 2001 +From: Jerome Duval +Date: Fri, 24 Nov 2023 18:10:57 +0100 +Subject: blink: workaround v8 cache metadata being null + +this fixes a crash on youtube.com. + +diff --git a/src/3rdparty/chromium/third_party/blink/renderer/bindings/core/v8/script_controller.cc b/src/3rdparty/chromium/third_party/blink/renderer/bindings/core/v8/script_controller.cc +index 350e2f1..f63264f 100644 +--- a/src/3rdparty/chromium/third_party/blink/renderer/bindings/core/v8/script_controller.cc ++++ b/src/3rdparty/chromium/third_party/blink/renderer/bindings/core/v8/script_controller.cc +@@ -132,9 +132,9 @@ v8::Local ScriptController::ExecuteScriptAndReturnValue( + v8::MaybeLocal maybe_result; + maybe_result = V8ScriptRunner::RunCompiledScript( + GetIsolate(), script, GetFrame()->GetDocument()->ToExecutionContext()); +- probe::ProduceCompilationCache(frame_, source, script); +- V8CodeCache::ProduceCache(GetIsolate(), script, source, +- produce_cache_options); ++// probe::ProduceCompilationCache(frame_, source, script); ++// V8CodeCache::ProduceCache(GetIsolate(), script, source, ++// produce_cache_options); + + if (!maybe_result.ToLocal(&result)) { + return result; +-- +2.37.3 diff --git a/dev-qt/qtwebengine/qtwebengine-5.15.2.recipe b/dev-qt/qtwebengine/qtwebengine-5.15.2.recipe index 7084120ea..f0320cc5a 100644 --- a/dev-qt/qtwebengine/qtwebengine-5.15.2.recipe +++ b/dev-qt/qtwebengine/qtwebengine-5.15.2.recipe @@ -5,7 +5,7 @@ HOMEPAGE="https://www.qt.io" COPYRIGHT="2015-2020 The Qt Company Ltd." LICENSE="BSD (3-clause) GNU LGPL v2.1" -REVISION="1" +REVISION="2" SOURCE_URI="https://download.qt.io/official_releases/qt/${portVersion%.*}/$portVersion/submodules/qtwebengine-everywhere-src-$portVersion.tar.xz" CHECKSUM_SHA256="c8afca0e43d84f7bd595436fbe4d13a5bbdb81ec5104d605085d07545b6f91e0" SOURCE_DIR="qtwebengine-everywhere-src-$portVersion" @@ -103,6 +103,7 @@ BUILD_REQUIRES=" devel:libQt5Qml$secondaryArchSuffix devel:libQt5QmlModels$secondaryArchSuffix devel:libQt5Quick$secondaryArchSuffix + devel:libQt5UiTools$secondaryArchSuffix devel:libQt5WebChannel$secondaryArchSuffix devel:libsnappy$secondaryArchSuffix devel:libssl$secondaryArchSuffix @@ -137,6 +138,7 @@ BUILD() mkdir -p build && cd build qmake .. -- \ + -proprietary-codecs \ -system-ffmpeg \ -webp NINJAJOBS=-j1 make