# Copyright (c) 2009 The Chromium OS Authors. All rights reserved.
# Distributed under the terms of the GNU General Public License v2

# Chrome binaries currently use libjpeg-6b, so we need to mask out libjpeg-7
>=media-libs/jpeg-7

# TODO: Fix cross compile autoconf failure.
>sys-apps/kbd-1.13-r1

# TODO: Update our overlay to work with python-2.6.4-r1
>dev-lang/python-2.6.4

# TODO: Newer versions don't compile properly due to missing dm_* headers.
>sys-fs/lvm2-2.02.51-r3

# TODO: ARM is temporarily stuck on mesa-7.5.1-r1 but x86 uses a newer
# version so we mask out only mesa-7.5.2 here. This is a temporary measure
# until we can get per-board cascading profile support.
=media-libs/mesa-7.5.2

# TODO: Fix lsof to cross compile on ARM
>sys-process/lsof-4.81-r2

# TODO: Fix cross compile on ARM of gdbm-1.8.3-r4
>sys-libs/gdbm-1.8.3-r3

# TODO: Fails with message about not knowing what kernel to use.
# Also applies patch which allows fuse to be linked with gold:
# http://sourceforge.net/mailarchive/message.php?msg_name=AANLkTi%3DKjY0nZvnb4ncc-BdhUGV8WmQ%3Dc2h-foUXSzRi%40mail.gmail.com
>sys-fs/fuse-2.7.4-r2

# TODO: The dbus-python-0.83.1 ebuild puts stuff in /usr/lib64.
>dev-python/dbus-python-0.83.0-r1

# libpng security vulnerability fix
<media-libs/libpng-1.2.44

# The following are here because we override the ebuilds from the
# portage tree for a reason other than adding an ebuild from upstream
# that wasn't yet in our portage tree. We want to keep using our
# version of these packages even if a newer stable version becomes
# available in portage:

# Required patch; pending work to upstream.
>net-dialup/ppp-2.4.4-r23

# Cross compile fix in the ebuild, and patch(es) from the upstream.
>x11-libs/libxcb-1.5-r1

# Cross compile fix in the ebuild (Icedtea -> cups -> libgcrypt).
>dev-libs/libgcrypt-1.4.6

# Masked all upstream ebuilds, unupstreamable work in local copy
>=net-misc/dhcpcd-5.1.5

# Masked all upstream ebuilds
>=net-wireless/wpa_supplicant-0.7.3

# Avoid using old known-vulnerable versions.  Upstream also installs the
# plugin to a different place than where the chromeos-chrome ebuild expects
# to find it, so ensure that we don't start using newer upstream versions.
<www-plugins/adobe-flash-10.3.181.26
>www-plugins/adobe-flash-10.3.181.26

# Masked old packages that had old ${PV} numbering scheme
>=app-i18n/ibus-mozc-29

# Custom patches
>sys-boot/syslinux-3.83-r3

# Mask until chromiumos specific patches are added to newer upstream ebuilds
>x11-drivers/xf86-input-mouse-1.7.0-r1

