git: 5406ac7fadd4 - main - www/firefox: fix build on powerpc64le
- Go to: [ bottom of page ] [ top of archives ] [ this month ]
Date: Tue, 05 Apr 2022 02:16:09 UTC
The branch main has been updated by pkubaj:
URL: https://cgit.FreeBSD.org/ports/commit/?id=5406ac7fadd46dcbffc8d36a2dea7158cf0dad89
commit 5406ac7fadd46dcbffc8d36a2dea7158cf0dad89
Author: Piotr Kubaj <pkubaj@FreeBSD.org>
AuthorDate: 2022-04-05 02:12:42 +0000
Commit: Piotr Kubaj <pkubaj@FreeBSD.org>
CommitDate: 2022-04-05 02:12:42 +0000
www/firefox: fix build on powerpc64le
ld: error: undefined hidden symbol: mozilla::VideoFramePool::~VideoFramePool()
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::~FFmpegVideoDecoder())
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::DoDecode(mozilla::MediaRawData*, unsigned char*, int, bool*, nsTArray<RefPtr<mozilla::MediaData> >&))
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::ProcessShutdown())
>>> referenced 4 more times
ld: error: undefined hidden symbol: mozilla::VideoFramePool::ReleaseUnusedVAAPIFrames()
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::DoDecode(mozilla::MediaRawData*, unsigned char*, int, bool*, nsTArray<RefPtr<mozilla::MediaData> >&))
>>> referenced by Unified_cpp_ffmpeg_ffmpeg590.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg59/Unified_cpp_ffmpeg_ffmpeg590.o:(mozilla::FFmpegVideoDecoder<59>::DoDecode(mozilla::MediaRawData*, unsigned char*, int, bool*, nsTArray<RefPtr<mozilla::MediaData> >&))
ld: error: undefined hidden symbol: mozilla::VideoFramePool::VideoFramePool()
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::DoDecode(mozilla::MediaRawData*, unsigned char*, int, bool*, nsTArray<RefPtr<mozilla::MediaData> >&))
>>> referenced by Unified_cpp_ffmpeg_ffmpeg590.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg59/Unified_cpp_ffmpeg_ffmpeg590.o:(mozilla::FFmpegVideoDecoder<59>::DoDecode(mozilla::MediaRawData*, unsigned char*, int, bool*, nsTArray<RefPtr<mozilla::MediaData> >&))
ld: error: undefined hidden symbol: mozilla::VideoFramePool::GetVideoFrameSurface(_VADRMPRIMESurfaceDescriptor&, AVCodecContext*, AVFrame*, mozilla::FFmpegLibWrapper*)
>>> referenced by Unified_cpp_ffmpeg_ffmpeg580.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg58/Unified_cpp_ffmpeg_ffmpeg580.o:(mozilla::FFmpegVideoDecoder<58>::CreateImageVAAPI(long, long, long, nsTArray<RefPtr<mozilla::MediaData> >&))
>>> referenced by Unified_cpp_ffmpeg_ffmpeg590.cpp
>>> /wrkdirs/usr/ports/www/firefox/work/.build/toolkit/library/build/../../../dom/media/platforms/ffmpeg/ffmpeg59/Unified_cpp_ffmpeg_ffmpeg590.o:(mozilla::FFmpegVideoDecoder<59>::CreateImageVAAPI(long, long, long, nsTArray<RefPtr<mozilla::MediaData> >&))
Upstream issue at https://bugzilla.mozilla.org/show_bug.cgi?id=1758610.
A
---
www/firefox/files/patch-bug1758610 | 365 +++++++++++++++++++++++++++++++++++++
1 file changed, 365 insertions(+)
diff --git a/www/firefox/files/patch-bug1758610 b/www/firefox/files/patch-bug1758610
new file mode 100644
index 000000000000..f83eb4ea2004
--- /dev/null
+++ b/www/firefox/files/patch-bug1758610
@@ -0,0 +1,365 @@
+--- dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp.orig 2022-03-30 23:24:44 UTC
++++ dom/media/platforms/ffmpeg/FFmpegVideoDecoder.cpp
+@@ -814,7 +814,7 @@ MediaResult FFmpegVideoDecoder<LIBAV_VER>::DoDecode(
+ # ifdef MOZ_WAYLAND_USE_VAAPI
+ // Create VideoFramePool in case we need it.
+ if (!mVideoFramePool && mEnableHardwareDecoding) {
+- mVideoFramePool = MakeUnique<VideoFramePool>();
++ mVideoFramePool = MakeUnique<VideoFramePool<LIBAV_VER>>();
+ }
+
+ // Release unused VA-API surfaces before avcodec_receive_frame() as
+--- dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h.orig 2022-03-30 23:24:44 UTC
++++ dom/media/platforms/ffmpeg/FFmpegVideoDecoder.h
+@@ -16,6 +16,9 @@
+ #if LIBAVCODEC_VERSION_MAJOR >= 57 && LIBAVUTIL_VERSION_MAJOR >= 56
+ # include "mozilla/layers/TextureClient.h"
+ #endif
++#ifdef MOZ_WAYLAND_USE_VAAPI
++# include "FFmpegVideoFramePool.h"
++#endif
+
+ struct _VADRMPRIMESurfaceDescriptor;
+ typedef struct _VADRMPRIMESurfaceDescriptor VADRMPRIMESurfaceDescriptor;
+@@ -23,7 +26,6 @@ typedef struct _VADRMPRIMESurfaceDescriptor VADRMPRIME
+ namespace mozilla {
+
+ class ImageBufferWrapper;
+-class VideoFramePool;
+
+ template <int V>
+ class FFmpegVideoDecoder : public FFmpegDataDecoder<V> {};
+@@ -138,7 +140,7 @@ class FFmpegVideoDecoder<LIBAV_VER>
+ AVBufferRef* mVAAPIDeviceContext;
+ bool mEnableHardwareDecoding;
+ VADisplay mDisplay;
+- UniquePtr<VideoFramePool> mVideoFramePool;
++ UniquePtr<VideoFramePool<LIBAV_VER>> mVideoFramePool;
+ static nsTArray<AVCodecID> mAcceleratedFormats;
+ #endif
+ RefPtr<KnowsCompositor> mImageAllocator;
+--- dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp.orig 2022-03-31 01:24:44.000000000 +0200
++++ dom/media/platforms/ffmpeg/FFmpegVideoFramePool.cpp 2022-04-05 00:06:31.002795000 +0200
+@@ -5,6 +5,7 @@
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+ #include "FFmpegVideoFramePool.h"
++#include "PlatformDecoderModule.h"
+ #include "FFmpegLog.h"
+ #include "mozilla/widget/DMABufLibWrapper.h"
+ #include "libavutil/pixfmt.h"
+@@ -15,14 +16,14 @@
+
+ namespace mozilla {
+
+-RefPtr<layers::Image> VideoFrameSurfaceVAAPI::GetAsImage() {
++RefPtr<layers::Image> VideoFrameSurface<LIBAV_VER>::GetAsImage() {
+ return new layers::DMABUFSurfaceImage(mSurface);
+ }
+
+-VideoFrameSurfaceVAAPI::VideoFrameSurfaceVAAPI(DMABufSurface* aSurface)
++VideoFrameSurface<LIBAV_VER>::VideoFrameSurface(DMABufSurface* aSurface)
+ : mSurface(aSurface),
+ mLib(nullptr),
+- mAVHWFramesContext(nullptr),
++ mAVHWDeviceContext(nullptr),
+ mHWAVBuffer(nullptr) {
+ // Create global refcount object to track mSurface usage over
+ // gects rendering engine. We can't release it until it's used
+@@ -30,22 +31,22 @@
+ MOZ_ASSERT(mSurface);
+ MOZ_RELEASE_ASSERT(mSurface->GetAsDMABufSurfaceYUV());
+ mSurface->GlobalRefCountCreate();
+- FFMPEG_LOG("VideoFrameSurfaceVAAPI: creating surface UID = %d",
++ FFMPEG_LOG("VideoFrameSurface: creating surface UID = %d",
+ mSurface->GetUID());
+ }
+
+-void VideoFrameSurfaceVAAPI::LockVAAPIData(AVCodecContext* aAVCodecContext,
+- AVFrame* aAVFrame,
+- FFmpegLibWrapper* aLib) {
+- FFMPEG_LOG("VideoFrameSurfaceVAAPI: VAAPI locking dmabuf surface UID = %d",
++void VideoFrameSurface<LIBAV_VER>::LockVAAPIData(
++ AVCodecContext* aAVCodecContext, AVFrame* aAVFrame,
++ FFmpegLibWrapper* aLib) {
++ FFMPEG_LOG("VideoFrameSurface: VAAPI locking dmabuf surface UID = %d",
+ mSurface->GetUID());
+ mLib = aLib;
+- mAVHWFramesContext = aLib->av_buffer_ref(aAVCodecContext->hw_frames_ctx);
++ mAVHWDeviceContext = aLib->av_buffer_ref(aAVCodecContext->hw_device_ctx);
+ mHWAVBuffer = aLib->av_buffer_ref(aAVFrame->buf[0]);
+ }
+
+-void VideoFrameSurfaceVAAPI::ReleaseVAAPIData(bool aForFrameRecycle) {
+- FFMPEG_LOG("VideoFrameSurfaceVAAPI: VAAPI releasing dmabuf surface UID = %d",
++void VideoFrameSurface<LIBAV_VER>::ReleaseVAAPIData(bool aForFrameRecycle) {
++ FFMPEG_LOG("VideoFrameSurface: VAAPI releasing dmabuf surface UID = %d",
+ mSurface->GetUID());
+
+ // It's possible to unref GPU data while IsUsed() is still set.
+@@ -56,7 +57,7 @@
+ // is closed.
+ if (mLib) {
+ mLib->av_buffer_unref(&mHWAVBuffer);
+- mLib->av_buffer_unref(&mAVHWFramesContext);
++ mLib->av_buffer_unref(&mAVHWDeviceContext);
+ }
+
+ // If we want to recycle the frame, make sure it's not used
+@@ -67,43 +68,44 @@
+ }
+ }
+
+-VideoFrameSurfaceVAAPI::~VideoFrameSurfaceVAAPI() {
+- FFMPEG_LOG("VideoFrameSurfaceVAAPI: deleting dmabuf surface UID = %d",
++VideoFrameSurface<LIBAV_VER>::~VideoFrameSurface() {
++ FFMPEG_LOG("VideoFrameSurface: deleting dmabuf surface UID = %d",
+ mSurface->GetUID());
+ // We're about to quit, no need to recycle the frames.
+ ReleaseVAAPIData(/* aForFrameRecycle */ false);
+ }
+
+-VideoFramePool::VideoFramePool() : mSurfaceLock("VideoFramePoolSurfaceLock") {}
++VideoFramePool<LIBAV_VER>::VideoFramePool()
++ : mSurfaceLock("VideoFramePoolSurfaceLock") {}
+
+-VideoFramePool::~VideoFramePool() {
++VideoFramePool<LIBAV_VER>::~VideoFramePool() {
+ MutexAutoLock lock(mSurfaceLock);
+ mDMABufSurfaces.Clear();
+ }
+
+-void VideoFramePool::ReleaseUnusedVAAPIFrames() {
++void VideoFramePool<LIBAV_VER>::ReleaseUnusedVAAPIFrames() {
+ MutexAutoLock lock(mSurfaceLock);
+ for (const auto& surface : mDMABufSurfaces) {
+- auto* vaapiSurface = surface->AsVideoFrameSurfaceVAAPI();
+- if (!vaapiSurface->IsUsed()) {
+- vaapiSurface->ReleaseVAAPIData();
++ if (!surface->IsUsed()) {
++ surface->ReleaseVAAPIData();
+ }
+ }
+ }
+
+-RefPtr<VideoFrameSurface> VideoFramePool::GetFreeVideoFrameSurface() {
++RefPtr<VideoFrameSurface<LIBAV_VER>>
++VideoFramePool<LIBAV_VER>::GetFreeVideoFrameSurface() {
+ for (auto& surface : mDMABufSurfaces) {
+ if (surface->IsUsed()) {
+ continue;
+ }
+- auto* vaapiSurface = surface->AsVideoFrameSurfaceVAAPI();
+- vaapiSurface->ReleaseVAAPIData();
++ surface->ReleaseVAAPIData();
+ return surface;
+ }
+ return nullptr;
+ }
+
+-RefPtr<VideoFrameSurface> VideoFramePool::GetVideoFrameSurface(
++RefPtr<VideoFrameSurface<LIBAV_VER>>
++VideoFramePool<LIBAV_VER>::GetVideoFrameSurface(
+ VADRMPRIMESurfaceDescriptor& aVaDesc, AVCodecContext* aAVCodecContext,
+ AVFrame* aAVFrame, FFmpegLibWrapper* aLib) {
+ if (aVaDesc.fourcc != VA_FOURCC_NV12 && aVaDesc.fourcc != VA_FOURCC_YV12 &&
+@@ -113,7 +115,8 @@
+ }
+
+ MutexAutoLock lock(mSurfaceLock);
+- RefPtr<VideoFrameSurface> videoSurface = GetFreeVideoFrameSurface();
++ RefPtr<VideoFrameSurface<LIBAV_VER>> videoSurface =
++ GetFreeVideoFrameSurface();
+ if (!videoSurface) {
+ RefPtr<DMABufSurfaceYUV> surface =
+ DMABufSurfaceYUV::CreateYUVSurface(aVaDesc);
+@@ -121,7 +124,8 @@
+ return nullptr;
+ }
+ FFMPEG_LOG("Created new VA-API DMABufSurface UID = %d", surface->GetUID());
+- RefPtr<VideoFrameSurfaceVAAPI> surf = new VideoFrameSurfaceVAAPI(surface);
++ RefPtr<VideoFrameSurface<LIBAV_VER>> surf =
++ new VideoFrameSurface<LIBAV_VER>(surface);
+ if (!mTextureCreationWorks) {
+ mTextureCreationWorks = Some(surface->VerifyTextureCreation());
+ }
+@@ -138,11 +142,8 @@
+ }
+ FFMPEG_LOG("Reusing VA-API DMABufSurface UID = %d", surface->GetUID());
+ }
+-
+- auto* vaapiSurface = videoSurface->AsVideoFrameSurfaceVAAPI();
+- vaapiSurface->LockVAAPIData(aAVCodecContext, aAVFrame, aLib);
+- vaapiSurface->MarkAsUsed();
+-
++ videoSurface->LockVAAPIData(aAVCodecContext, aAVFrame, aLib);
++ videoSurface->MarkAsUsed();
+ return videoSurface;
+ }
+
+--- dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h.orig 2022-03-31 01:24:44.000000000 +0200
++++ dom/media/platforms/ffmpeg/FFmpegVideoFramePool.h 2022-04-05 00:23:32.421765000 +0200
+@@ -7,8 +7,9 @@
+ #ifndef __FFmpegVideoFramePool_h__
+ #define __FFmpegVideoFramePool_h__
+
+-#include "FFmpegVideoDecoder.h"
+ #include "FFmpegLibWrapper.h"
++#include "FFmpegLibs.h"
++#include "FFmpegLog.h"
+
+ #include "mozilla/layers/DMABUFSurfaceImage.h"
+ #include "mozilla/widget/DMABufLibWrapper.h"
+@@ -16,43 +17,16 @@
+
+ namespace mozilla {
+
+-class VideoFramePool;
+-class VideoFrameSurfaceVAAPI;
+-
+-class VideoFrameSurface {
+- public:
+- NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameSurface)
+-
+- VideoFrameSurface() = default;
+-
+- virtual VideoFrameSurfaceVAAPI* AsVideoFrameSurfaceVAAPI() { return nullptr; }
+-
+- virtual void SetYUVColorSpace(gfx::YUVColorSpace aColorSpace) = 0;
+- virtual void SetColorRange(gfx::ColorRange aColorRange) = 0;
+-
+- virtual RefPtr<DMABufSurfaceYUV> GetDMABufSurface() { return nullptr; };
+- virtual RefPtr<layers::Image> GetAsImage() = 0;
+-
+- // Don't allow VideoFrameSurface plain copy as it leads to
+- // unexpected DMABufSurface/HW buffer releases and we don't want to
+- // deep copy them.
+- VideoFrameSurface(const VideoFrameSurface&) = delete;
+- const VideoFrameSurface& operator=(VideoFrameSurface const&) = delete;
+-
+- protected:
+- virtual ~VideoFrameSurface(){};
+-};
+-
+-// VideoFrameSurfaceVAAPI holds a reference to GPU data with a video frame.
++// VideoFrameSurface holds a reference to GPU data with a video frame.
+ //
+ // Actual GPU pixel data are stored at DMABufSurface and
+ // DMABufSurface is passed to gecko GL rendering pipeline via.
+ // DMABUFSurfaceImage.
+ //
+-// VideoFrameSurfaceVAAPI can optionally hold VA-API ffmpeg related data to keep
++// VideoFrameSurface can optionally hold VA-API ffmpeg related data to keep
+ // GPU data locked untill we need them.
+ //
+-// VideoFrameSurfaceVAAPI is used for both HW accelerated video decoding
++// VideoFrameSurface is used for both HW accelerated video decoding
+ // (VA-API) and ffmpeg SW decoding.
+ //
+ // VA-API scenario
+@@ -72,13 +46,24 @@
+ // Unfortunately there isn't any obvious way how to mark particular VASurface
+ // as used. The best we can do is to hold a reference to particular AVBuffer
+ // from decoded AVFrame and AVHWFramesContext which owns the AVBuffer.
+-class VideoFrameSurfaceVAAPI final : public VideoFrameSurface {
+- friend class VideoFramePool;
++template <int V>
++class VideoFrameSurface {};
++template <>
++class VideoFrameSurface<LIBAV_VER>;
+
++template <int V>
++class VideoFramePool {};
++template <>
++class VideoFramePool<LIBAV_VER>;
++
++template <>
++class VideoFrameSurface<LIBAV_VER> {
++ friend class VideoFramePool<LIBAV_VER>;
++
+ public:
+- explicit VideoFrameSurfaceVAAPI(DMABufSurface* aSurface);
++ NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VideoFrameSurface)
+
+- VideoFrameSurfaceVAAPI* AsVideoFrameSurfaceVAAPI() final { return this; }
++ explicit VideoFrameSurface(DMABufSurface* aSurface);
+
+ void SetYUVColorSpace(mozilla::gfx::YUVColorSpace aColorSpace) {
+ mSurface->GetAsDMABufSurfaceYUV()->SetYUVColorSpace(aColorSpace);
+@@ -93,6 +78,12 @@
+
+ RefPtr<layers::Image> GetAsImage();
+
++ // Don't allow VideoFrameSurface plain copy as it leads to
++ // unexpected DMABufSurface/HW buffer releases and we don't want to
++ // deep copy them.
++ VideoFrameSurface(const VideoFrameSurface&) = delete;
++ const VideoFrameSurface& operator=(VideoFrameSurface const&) = delete;
++
+ protected:
+ // Lock VAAPI related data
+ void LockVAAPIData(AVCodecContext* aAVCodecContext, AVFrame* aAVFrame,
+@@ -107,32 +98,33 @@
+ void MarkAsUsed() { mSurface->GlobalRefAdd(); }
+
+ private:
+- virtual ~VideoFrameSurfaceVAAPI();
++ virtual ~VideoFrameSurface();
+
+ const RefPtr<DMABufSurface> mSurface;
+ const FFmpegLibWrapper* mLib;
+- AVBufferRef* mAVHWFramesContext;
++ AVBufferRef* mAVHWDeviceContext;
+ AVBufferRef* mHWAVBuffer;
+ };
+
+ // VideoFramePool class is thread-safe.
+-class VideoFramePool final {
++template <>
++class VideoFramePool<LIBAV_VER> {
+ public:
+ VideoFramePool();
+ ~VideoFramePool();
+
+- RefPtr<VideoFrameSurface> GetVideoFrameSurface(
++ RefPtr<VideoFrameSurface<LIBAV_VER>> GetVideoFrameSurface(
+ VADRMPRIMESurfaceDescriptor& aVaDesc, AVCodecContext* aAVCodecContext,
+ AVFrame* aAVFrame, FFmpegLibWrapper* aLib);
+ void ReleaseUnusedVAAPIFrames();
+
+ private:
+- RefPtr<VideoFrameSurface> GetFreeVideoFrameSurface();
++ RefPtr<VideoFrameSurface<LIBAV_VER>> GetFreeVideoFrameSurface();
+
+ private:
+ // Protect mDMABufSurfaces pool access
+ Mutex mSurfaceLock;
+- nsTArray<RefPtr<VideoFrameSurfaceVAAPI>> mDMABufSurfaces;
++ nsTArray<RefPtr<VideoFrameSurface<LIBAV_VER>>> mDMABufSurfaces;
+ // We may fail to create texture over DMABuf memory due to driver bugs so
+ // check that before we export first DMABuf video frame.
+ Maybe<bool> mTextureCreationWorks;
+--- dom/media/platforms/ffmpeg/ffmpeg58/moz.build.orig 2022-03-30 23:24:44 UTC
++++ dom/media/platforms/ffmpeg/ffmpeg58/moz.build
+@@ -30,6 +30,9 @@ if CONFIG['MOZ_WAYLAND']:
+ CXXFLAGS += CONFIG['MOZ_GTK3_CFLAGS']
+ DEFINES['MOZ_WAYLAND_USE_VAAPI'] = 1
+ USE_LIBS += ['mozva']
++ UNIFIED_SOURCES += [
++ '../FFmpegVideoFramePool.cpp',
++ ]
+
+ include("/ipc/chromium/chromium-config.mozbuild")
+
+--- dom/media/platforms/ffmpeg/ffmpeg59/moz.build.orig 2022-03-30 23:24:44 UTC
++++ dom/media/platforms/ffmpeg/ffmpeg59/moz.build
+@@ -30,6 +30,9 @@ if CONFIG["MOZ_WAYLAND"]:
+ CXXFLAGS += CONFIG["MOZ_GTK3_CFLAGS"]
+ DEFINES["MOZ_WAYLAND_USE_VAAPI"] = 1
+ USE_LIBS += ["mozva"]
++ UNIFIED_SOURCES += [
++ "../FFmpegVideoFramePool.cpp",
++ ]
+
+ include("/ipc/chromium/chromium-config.mozbuild")
+