This patch fixes TV Onscreen build issues for M120.
Change-Id: I779c25f22364f863fe08b352b628e1cb24d68d9c
Signed-off-by: venu.musham <venu.musham@samsung.com>
Signed-off-by: v-saha <v.saha@samsung.com>
# found in the LICENSE file.
import("//build/config/linux/pkg_config.gni")
+if (use_efl) {
+ import("//tizen_src/build/config/tizen_features.gni")
+}
declare_args() {
# Controls whether the build should use the version of libffi library shipped
# on Linux, libffi must be statically linked to prevent a situation where the
# runtime version of libffi is different from the build-time version from the
# sysroot.
- use_system_libffi = default_toolchain == "//build/toolchain/cros:target"
+ use_system_libffi =
+ default_toolchain == "//build/toolchain/cros:target" || build_chrome
}
if (use_system_libffi) {
export EVAS_GL_NO_BLACKLIST=1
-export LD_LIBRARY_PATH=$PWD/out.x64/Dependencies/Root/lib64/:$LD_LIBRARY_PATH
-./out.x64/chrome $1 --no-sandbox --ignore-gpu-blocklist --use-gl=egl --ozone-platform=efl --window-size=800,600
\ No newline at end of file
+export LD_LIBRARY_PATH=$PWD/out.chrome.x64/Dependencies/Root/lib64/:$LD_LIBRARY_PATH
+./out.chrome.x64/chrome $1 --no-sandbox --ignore-gpu-blocklist --use-gl=egl --ozone-platform=efl --window-size=800,600
ldflags += [ "--collect-inputs-only" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"app/chrome_main_linux.cc",
"app/chrome_main_linux.h",
"performance_monitor/metric_evaluator_helper_posix.h",
]
}
- if (enable_supervised_users &&
- (is_android || is_win || is_linux || is_mac || is_chromeos_lacros)) {
+ if (enable_supervised_users && (is_android || is_win || is_linux || is_mac ||
+ is_chromeos_lacros || is_tizen)) {
sources += [
"metrics/family_link_user_metrics_provider.cc",
"metrics/family_link_user_metrics_provider.h",
]
}
- if (is_linux || is_win || is_mac || is_android) {
+ if (is_linux || is_win || is_mac || is_android || is_tizen) {
sources += [
"enterprise/idle/action.cc",
"enterprise/idle/action.h",
]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"metrics/pressure/pressure_metrics.cc",
"metrics/pressure/pressure_metrics.h",
]
}
- if (is_win || is_mac || is_linux || is_chromeos) {
+ if (is_win || is_mac || is_linux || is_chromeos || is_tizen) {
deps += [
"//components/power_metrics",
"//components/user_notes:features",
"supervised_user/chromeos/supervised_user_web_content_handler_impl.h",
]
}
- if (is_win || is_linux || is_mac) {
+ if (is_win || is_linux || is_mac || is_tizen) {
sources += [
"supervised_user/linux_mac_windows/supervised_user_web_content_handler_impl.cc",
"supervised_user/linux_mac_windows/supervised_user_web_content_handler_impl.h",
#endif // BUILDFLAG(ENABLE_PLUGINS)
#if !BUILDFLAG(IS_ANDROID)
-#if defined(EWK_BRINGUP) && !BUILDFLAG(IS_TIZEN) // FIXME: m108 bringup
storage_monitor::StorageMonitor::Create();
#endif
-#endif
platform_part_->PreMainMessageLoopRun();
*UrlLanguageHistogramFactory::GetForBrowserContext(profile));
#endif // BUILDFLAG(IS_CHROMEOS_ASH)
-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC)
+#if (BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN)) || BUILDFLAG(IS_WIN) || \
+ BUILDFLAG(IS_MAC) // FIXME : m120 bringup
if (headless::IsHeadlessMode()) {
headless::ReportHeadlessActionMetrics();
}
// initialization depend on FeatureList, and is done elsewhere.
#endif // BUILDFLAG(IS_CHROMEOS)
-#if !BUILDFLAG(IS_CHROMEOS) && !BUILDFLAG(IS_TIZEN)
+#if !BUILDFLAG(IS_CHROMEOS)
bluez::BluezDBusManager::Initialize(nullptr /* system_bus */);
// Set up crypt config. This needs to be done before anything starts the
ContentSettingsType type;
ContentSettingsPattern primary_pattern;
ContentSettingsPattern secondary_pattern;
+ ContentSettingEntry(ContentSettingsType type,
+ ContentSettingsPattern primary_pattern,
+ ContentSettingsPattern secondary_pattern)
+ : type(type),
+ primary_pattern(primary_pattern),
+ secondary_pattern(secondary_pattern) {}
};
void DeleteEntriesAndNotify(
std::string name;
std::string domain;
std::string token;
+ SAMLProfileAttributes() {}
+ SAMLProfileAttributes(std::string name, std::string domain, std::string token)
+ : name(name), domain(domain), token(token) {}
};
constexpr char kNameAttributeKey[] = "name";
}
AddressCountryCode address_country_code =
+#if !defined(EWK_BRINGUP) // FIXME : m120 bringup
country_code.has_value()
? AddressCountryCode(std::string(*country_code))
: autofill::i18n_model_definition::kLegacyHierarchyCountryCode;
+#else
+ country_code.has_value() ? AddressCountryCode(std::string(*country_code))
+ : AddressCountryCode(std::string("XX"));
+#endif
return autofill::AutofillProfile(source, address_country_code);
}
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#if !defined(EWK_BRINGUP) // FIXME: m120 bringup
#include <span> // std::size.
+#endif
#include "base/containers/contains.h"
#include "base/strings/stringprintf.h"
}
}
- using enum UmaLinuxDistro;
// This array must be kept sorted since it is binary searched.
constexpr std::pair<const char*, UmaLinuxDistro> kDistroPrefixes[] = {
- {"alma", kAlma},
- {"alpine", kAlpine},
- {"alter", kAlter},
- {"amazon", kAmazon},
- {"anarchy", kAnarchy},
- {"antergos", kAntergos},
- {"antix", kAntiX},
- {"aoscos", kAoscOs},
- {"aperio", kAperio},
- {"apricity", kApricity},
- {"arch", kArch},
- {"arcolinux", kArcoLinux},
- {"artix", kArtix},
- {"arya", kArya},
- {"asteroidos", kAsteroidOs},
- {"ataraxia", kJanus},
- {"bedrock", kBedrock},
- {"bitrig", kBitrig},
- {"blackarch", kBlackArch},
- {"blag", kBlag},
- {"blankon", kBlankOn},
- {"bluelight", kBlueLight},
- {"bodhi", kBodhi},
- {"bonsai", kBonsai},
- {"bunsenlabs", kBunsenLabs},
- {"calculate", kCalculate},
- {"carbs", kCarbs},
- {"cblmariner", kCblMariner},
- {"celos", kCelOs},
- {"centos", kCentOs},
- {"chakra", kChakra},
- {"chaletos", kChaletOs},
- {"chapeau", kChapeau},
- {"cleanjaro", kCleanjaro},
- {"clearlinux", kClearLinux},
- {"clearos", kClearOs},
- {"clover", kClover},
- {"condres", kCondres},
- {"containerlinux", kContainerLinux},
- {"crux", kCrux},
- {"crystallinux", kCrystalLinux},
- {"cucumber", kCucumber},
- {"cyberos", kCyberOs},
- {"dahlia", kDahlia},
- {"darkos", kDarkOs},
- {"debian", kDebian},
- {"deepin", kDeepin},
- {"desaos", kDesaOs},
- {"devuan", kDevuan},
- {"dracos", kDracOs},
- {"drauger", kDrauger},
- {"elementary", kElementary},
- {"endeavouros", kEndeavourOs},
- {"endless", kEndless},
- {"eurolinux", kEuroLinux},
- {"exherbo", kExherbo},
- {"fedora", kFedora},
- {"feren", kFeren},
- {"frugalware", kFrugalware},
- {"funtoo", kFuntoo},
- {"galliumos", kGalliumOs},
- {"garuda", kGaruda},
- {"gentoo", kGentoo},
- {"glaucus", kGlaucus},
- {"gnewsense", kGnewSense},
- {"gnome", kGnome},
- {"gobolinux", kGoboLinux},
- {"grombyang", kGrombyang},
- {"hash", kHash},
- {"huayra", kHuayra},
- {"hyperbola", kHyperbola},
- {"i3buntu", kUbuntu},
- {"iglu", kIglu},
- {"instantos", kInstantOs},
- {"itc", kItc},
- {"janus", kJanus},
- {"kaisen", kKaisen},
- {"kali", kKali},
- {"kaos", kKaOs},
- {"kde", kKde},
- {"kibojoe", kKibojoe},
- {"kogaion", kKogaion},
- {"korora", kKorora},
- {"kslinux", kKsLinux},
- {"kubuntu", kKubuntu},
- {"langitketujuh", kLangitKetujuh},
- {"laxeros", kLaxerOs},
- {"lede", kLede},
- {"libreelec", kLibreElec},
- {"linuxlite", kLinuxLite},
- {"linuxmint", kLinuxMint},
- {"liveraizo", kLiveRaizo},
- {"lmde", kLmde},
- {"lubuntu", kLubuntu},
- {"lunar", kLunar},
- {"mageia", kMageia},
- {"magpieos", kMagpieOs},
- {"mandrake", kMandriva},
- {"mandriva", kMandriva},
- {"manjaro", kManjaro},
- {"maui", kMaui},
- {"mer", kMer},
- {"minix", kMinix},
- {"mint", kLinuxMint},
- {"mx", kMx},
- {"namib", kNamib},
- {"neptune", kNeptune},
- {"netrunner", kNetrunner},
- {"nitrux", kNitrux},
- {"nixos", kNixOs},
- {"nurunner", kNurunner},
- {"nutyx", kNutyX},
- {"obarun", kObarun},
- {"obrevenge", kObRevenge},
- {"openeuler", kOpenEuler},
- {"openindiana", kOpenIndiana},
- {"openmamba", kOpenMamba},
- {"openmandriva", kOpenMandriva},
- {"opensourcemediacenter", kOpenSourceMediaCenter},
- {"openstage", kOpenStage},
- {"opensuse", kOpenSuse},
- {"opensuseleap", kOpenSuseLeap},
- {"opensusetumbleweed", kOpenSuseTumbleweed},
- {"openwrt", kOpenWrt},
- {"oracle", kOracle},
- {"oselbrus", kOsElbrus},
- {"osmc", kOpenSourceMediaCenter},
- {"parabola", kParabola},
- {"pardus", kPardus},
- {"parrot", kParrot},
- {"parsix", kParsix},
- {"pclinuxos", kPcLinuxOs},
- {"pengwin", kPengwin},
- {"pentoo", kPentoo},
- {"peppermint", kPeppermint},
- {"pisi", kPisi},
- {"pnmlinux", kPnmLinux},
- {"popos", kPopOs},
- {"porteus", kPorteus},
- {"postmarketos", kPostMarketOs},
- {"precisepuppy", kPuppy},
- {"proxmox", kProxmox},
- {"puffos", kPuffOs},
- {"puppy", kPuppy},
- {"pureos", kPureOs},
- {"qubes", kQubes},
- {"qubyt", kQubyt},
- {"quibian", kQuibian},
- {"quirkywerewolf", kPuppy},
- {"radix", kRadix},
- {"raspbian", kRaspbian},
- {"reborn", kReborn},
- {"redcore", kRedcore},
- {"redhat", kRedhat},
- {"redstar", kRedStar},
- {"refracteddevuan", kRefractedDevuan},
- {"regata", kRegata},
- {"regolith", kRegolith},
- {"rhel", kRedhat},
- {"rocky", kRocky},
- {"rosa", kRosa},
- {"sabayon", kSabayon},
- {"sabotage", kSabotage},
- {"sailfish", kSailfish},
- {"salentos", kSalentOs},
- {"scientific", kScientific},
- {"semc", kSemc},
- {"septor", kSeptor},
- {"serene", kSerene},
- {"sharklinux", kSharkLinux},
- {"siduction", kSiduction},
- {"skiffos", kSkiffOs},
- {"slackware", kSlackware},
- {"slitaz", kSliTaz},
- {"smartos", kSmartOs},
- {"solus", kSolus},
- {"sourcemage", kSourceMage},
- {"sparky", kSparky},
- {"star", kStar},
- {"steamos", kSteamOs},
- {"suse", kOpenSuse},
- {"swagarch", kSwagArch},
- {"t2", kT2},
- {"tails", kTails},
- {"tearch", kTeArch},
- {"trisquel", kTrisquel},
- {"ubuntu", kUbuntu},
- {"univention", kUnivention},
- {"venom", kVenom},
- {"vnux", kVnux},
- {"void", kVoid},
- {"whpnmlinux", kPnmLinux},
- {"xferience", kXferience},
- {"xubuntu", kXubuntu},
- {"zorin", kZorin},
+ {"alma", UmaLinuxDistro::kAlma},
+ {"alpine", UmaLinuxDistro::kAlpine},
+ {"alter", UmaLinuxDistro::kAlter},
+ {"amazon", UmaLinuxDistro::kAmazon},
+ {"anarchy", UmaLinuxDistro::kAnarchy},
+ {"antergos", UmaLinuxDistro::kAntergos},
+ {"antix", UmaLinuxDistro::kAntiX},
+ {"aoscos", UmaLinuxDistro::kAoscOs},
+ {"aperio", UmaLinuxDistro::kAperio},
+ {"apricity", UmaLinuxDistro::kApricity},
+ {"arch", UmaLinuxDistro::kArch},
+ {"arcolinux", UmaLinuxDistro::kArcoLinux},
+ {"artix", UmaLinuxDistro::kArtix},
+ {"arya", UmaLinuxDistro::kArya},
+ {"asteroidos", UmaLinuxDistro::kAsteroidOs},
+ {"ataraxia", UmaLinuxDistro::kJanus},
+ {"bedrock", UmaLinuxDistro::kBedrock},
+ {"bitrig", UmaLinuxDistro::kBitrig},
+ {"blackarch", UmaLinuxDistro::kBlackArch},
+ {"blag", UmaLinuxDistro::kBlag},
+ {"blankon", UmaLinuxDistro::kBlankOn},
+ {"bluelight", UmaLinuxDistro::kBlueLight},
+ {"bodhi", UmaLinuxDistro::kBodhi},
+ {"bonsai", UmaLinuxDistro::kBonsai},
+ {"bunsenlabs", UmaLinuxDistro::kBunsenLabs},
+ {"calculate", UmaLinuxDistro::kCalculate},
+ {"carbs", UmaLinuxDistro::kCarbs},
+ {"cblmariner", UmaLinuxDistro::kCblMariner},
+ {"celos", UmaLinuxDistro::kCelOs},
+ {"centos", UmaLinuxDistro::kCentOs},
+ {"chakra", UmaLinuxDistro::kChakra},
+ {"chaletos", UmaLinuxDistro::kChaletOs},
+ {"chapeau", UmaLinuxDistro::kChapeau},
+ {"cleanjaro", UmaLinuxDistro::kCleanjaro},
+ {"clearlinux", UmaLinuxDistro::kClearLinux},
+ {"clearos", UmaLinuxDistro::kClearOs},
+ {"clover", UmaLinuxDistro::kClover},
+ {"condres", UmaLinuxDistro::kCondres},
+ {"containerlinux", UmaLinuxDistro::kContainerLinux},
+ {"crux", UmaLinuxDistro::kCrux},
+ {"crystallinux", UmaLinuxDistro::kCrystalLinux},
+ {"cucumber", UmaLinuxDistro::kCucumber},
+ {"cyberos", UmaLinuxDistro::kCyberOs},
+ {"dahlia", UmaLinuxDistro::kDahlia},
+ {"darkos", UmaLinuxDistro::kDarkOs},
+ {"debian", UmaLinuxDistro::kDebian},
+ {"deepin", UmaLinuxDistro::kDeepin},
+ {"desaos", UmaLinuxDistro::kDesaOs},
+ {"devuan", UmaLinuxDistro::kDevuan},
+ {"dracos", UmaLinuxDistro::kDracOs},
+ {"drauger", UmaLinuxDistro::kDrauger},
+ {"elementary", UmaLinuxDistro::kElementary},
+ {"endeavouros", UmaLinuxDistro::kEndeavourOs},
+ {"endless", UmaLinuxDistro::kEndless},
+ {"eurolinux", UmaLinuxDistro::kEuroLinux},
+ {"exherbo", UmaLinuxDistro::kExherbo},
+ {"fedora", UmaLinuxDistro::kFedora},
+ {"feren", UmaLinuxDistro::kFeren},
+ {"frugalware", UmaLinuxDistro::kFrugalware},
+ {"funtoo", UmaLinuxDistro::kFuntoo},
+ {"galliumos", UmaLinuxDistro::kGalliumOs},
+ {"garuda", UmaLinuxDistro::kGaruda},
+ {"gentoo", UmaLinuxDistro::kGentoo},
+ {"glaucus", UmaLinuxDistro::kGlaucus},
+ {"gnewsense", UmaLinuxDistro::kGnewSense},
+ {"gnome", UmaLinuxDistro::kGnome},
+ {"gobolinux", UmaLinuxDistro::kGoboLinux},
+ {"grombyang", UmaLinuxDistro::kGrombyang},
+ {"hash", UmaLinuxDistro::kHash},
+ {"huayra", UmaLinuxDistro::kHuayra},
+ {"hyperbola", UmaLinuxDistro::kHyperbola},
+ {"i3buntu", UmaLinuxDistro::kUbuntu},
+ {"iglu", UmaLinuxDistro::kIglu},
+ {"instantos", UmaLinuxDistro::kInstantOs},
+ {"itc", UmaLinuxDistro::kItc},
+ {"janus", UmaLinuxDistro::kJanus},
+ {"kaisen", UmaLinuxDistro::kKaisen},
+ {"kali", UmaLinuxDistro::kKali},
+ {"kaos", UmaLinuxDistro::kKaOs},
+ {"kde", UmaLinuxDistro::kKde},
+ {"kibojoe", UmaLinuxDistro::kKibojoe},
+ {"kogaion", UmaLinuxDistro::kKogaion},
+ {"korora", UmaLinuxDistro::kKorora},
+ {"kslinux", UmaLinuxDistro::kKsLinux},
+ {"kubuntu", UmaLinuxDistro::kKubuntu},
+ {"langitketujuh", UmaLinuxDistro::kLangitKetujuh},
+ {"laxeros", UmaLinuxDistro::kLaxerOs},
+ {"lede", UmaLinuxDistro::kLede},
+ {"libreelec", UmaLinuxDistro::kLibreElec},
+ {"linuxlite", UmaLinuxDistro::kLinuxLite},
+ {"linuxmint", UmaLinuxDistro::kLinuxMint},
+ {"liveraizo", UmaLinuxDistro::kLiveRaizo},
+ {"lmde", UmaLinuxDistro::kLmde},
+ {"lubuntu", UmaLinuxDistro::kLubuntu},
+ {"lunar", UmaLinuxDistro::kLunar},
+ {"mageia", UmaLinuxDistro::kMageia},
+ {"magpieos", UmaLinuxDistro::kMagpieOs},
+ {"mandrake", UmaLinuxDistro::kMandriva},
+ {"mandriva", UmaLinuxDistro::kMandriva},
+ {"manjaro", UmaLinuxDistro::kManjaro},
+ {"maui", UmaLinuxDistro::kMaui},
+ {"mer", UmaLinuxDistro::kMer},
+ {"minix", UmaLinuxDistro::kMinix},
+ {"mint", UmaLinuxDistro::kLinuxMint},
+ {"mx", UmaLinuxDistro::kMx},
+ {"namib", UmaLinuxDistro::kNamib},
+ {"neptune", UmaLinuxDistro::kNeptune},
+ {"netrunner", UmaLinuxDistro::kNetrunner},
+ {"nitrux", UmaLinuxDistro::kNitrux},
+ {"nixos", UmaLinuxDistro::kNixOs},
+ {"nurunner", UmaLinuxDistro::kNurunner},
+ {"nutyx", UmaLinuxDistro::kNutyX},
+ {"obarun", UmaLinuxDistro::kObarun},
+ {"obrevenge", UmaLinuxDistro::kObRevenge},
+ {"openeuler", UmaLinuxDistro::kOpenEuler},
+ {"openindiana", UmaLinuxDistro::kOpenIndiana},
+ {"openmamba", UmaLinuxDistro::kOpenMamba},
+ {"openmandriva", UmaLinuxDistro::kOpenMandriva},
+ {"opensourcemediacenter", UmaLinuxDistro::kOpenSourceMediaCenter},
+ {"openstage", UmaLinuxDistro::kOpenStage},
+ {"opensuse", UmaLinuxDistro::kOpenSuse},
+ {"opensuseleap", UmaLinuxDistro::kOpenSuseLeap},
+ {"opensusetumbleweed", UmaLinuxDistro::kOpenSuseTumbleweed},
+ {"openwrt", UmaLinuxDistro::kOpenWrt},
+ {"oracle", UmaLinuxDistro::kOracle},
+ {"oselbrus", UmaLinuxDistro::kOsElbrus},
+ {"osmc", UmaLinuxDistro::kOpenSourceMediaCenter},
+ {"parabola", UmaLinuxDistro::kParabola},
+ {"pardus", UmaLinuxDistro::kPardus},
+ {"parrot", UmaLinuxDistro::kParrot},
+ {"parsix", UmaLinuxDistro::kParsix},
+ {"pclinuxos", UmaLinuxDistro::kPcLinuxOs},
+ {"pengwin", UmaLinuxDistro::kPengwin},
+ {"pentoo", UmaLinuxDistro::kPentoo},
+ {"peppermint", UmaLinuxDistro::kPeppermint},
+ {"pisi", UmaLinuxDistro::kPisi},
+ {"pnmlinux", UmaLinuxDistro::kPnmLinux},
+ {"popos", UmaLinuxDistro::kPopOs},
+ {"porteus", UmaLinuxDistro::kPorteus},
+ {"postmarketos", UmaLinuxDistro::kPostMarketOs},
+ {"precisepuppy", UmaLinuxDistro::kPuppy},
+ {"proxmox", UmaLinuxDistro::kProxmox},
+ {"puffos", UmaLinuxDistro::kPuffOs},
+ {"puppy", UmaLinuxDistro::kPuppy},
+ {"pureos", UmaLinuxDistro::kPureOs},
+ {"qubes", UmaLinuxDistro::kQubes},
+ {"qubyt", UmaLinuxDistro::kQubyt},
+ {"quibian", UmaLinuxDistro::kQuibian},
+ {"quirkywerewolf", UmaLinuxDistro::kPuppy},
+ {"radix", UmaLinuxDistro::kRadix},
+ {"raspbian", UmaLinuxDistro::kRaspbian},
+ {"reborn", UmaLinuxDistro::kReborn},
+ {"redcore", UmaLinuxDistro::kRedcore},
+ {"redhat", UmaLinuxDistro::kRedhat},
+ {"redstar", UmaLinuxDistro::kRedStar},
+ {"refracteddevuan", UmaLinuxDistro::kRefractedDevuan},
+ {"regata", UmaLinuxDistro::kRegata},
+ {"regolith", UmaLinuxDistro::kRegolith},
+ {"rhel", UmaLinuxDistro::kRedhat},
+ {"rocky", UmaLinuxDistro::kRocky},
+ {"rosa", UmaLinuxDistro::kRosa},
+ {"sabayon", UmaLinuxDistro::kSabayon},
+ {"sabotage", UmaLinuxDistro::kSabotage},
+ {"sailfish", UmaLinuxDistro::kSailfish},
+ {"salentos", UmaLinuxDistro::kSalentOs},
+ {"scientific", UmaLinuxDistro::kScientific},
+ {"semc", UmaLinuxDistro::kSemc},
+ {"septor", UmaLinuxDistro::kSeptor},
+ {"serene", UmaLinuxDistro::kSerene},
+ {"sharklinux", UmaLinuxDistro::kSharkLinux},
+ {"siduction", UmaLinuxDistro::kSiduction},
+ {"skiffos", UmaLinuxDistro::kSkiffOs},
+ {"slackware", UmaLinuxDistro::kSlackware},
+ {"slitaz", UmaLinuxDistro::kSliTaz},
+ {"smartos", UmaLinuxDistro::kSmartOs},
+ {"solus", UmaLinuxDistro::kSolus},
+ {"sourcemage", UmaLinuxDistro::kSourceMage},
+ {"sparky", UmaLinuxDistro::kSparky},
+ {"star", UmaLinuxDistro::kStar},
+ {"steamos", UmaLinuxDistro::kSteamOs},
+ {"suse", UmaLinuxDistro::kOpenSuse},
+ {"swagarch", UmaLinuxDistro::kSwagArch},
+ {"t2", UmaLinuxDistro::kT2},
+ {"tails", UmaLinuxDistro::kTails},
+ {"tearch", UmaLinuxDistro::kTeArch},
+ {"trisquel", UmaLinuxDistro::kTrisquel},
+ {"ubuntu", UmaLinuxDistro::kUbuntu},
+ {"univention", UmaLinuxDistro::kUnivention},
+ {"venom", UmaLinuxDistro::kVenom},
+ {"vnux", UmaLinuxDistro::kVnux},
+ {"void", UmaLinuxDistro::kVoid},
+ {"whpnmlinux", UmaLinuxDistro::kPnmLinux},
+ {"xferience", UmaLinuxDistro::kXferience},
+ {"xubuntu", UmaLinuxDistro::kXubuntu},
+ {"zorin", UmaLinuxDistro::kZorin},
};
struct Compare {
bool operator()(const std::string& string,
g_system_network_context_manager = nullptr;
}
-#if BUILDFLAG(IS_LINUX)
+#if BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
SystemNetworkContextManager::GssapiLibraryLoadObserver::
GssapiLibraryLoadObserver(SystemNetworkContextManager* owner)
: owner_(owner) {}
OnNewHttpAuthDynamicParams(http_auth_dynamic_params);
network_service->ConfigureHttpAuthPrefs(std::move(http_auth_dynamic_params));
-#if BUILDFLAG(IS_LINUX)
+#if BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
gssapi_library_loader_observer_.Install(network_service);
#endif // BUILDFLAG(IS_LINUX)
# Device signals sharing currently only supports win, mac, linux and
# ash-chromeos, so the corresponding consent functionality are
# limited to the same set of platforms.
- if (is_win || is_mac || is_linux || is_chromeos_ash) {
+ if (is_win || is_mac || is_linux || is_chromeos_ash || is_tizen) {
sources += [
"device_signals_consent/consent_requester.h",
"views/device_signals_consent/consent_dialog_coordinator.cc",
base::TimeTicks match_selection_timestamp;
bool url_typed_without_scheme;
bool url_typed_with_http_scheme;
+ NavigationParams() {}
+ NavigationParams(GURL destination_url,
+ WindowOpenDisposition disposition,
+ ui::PageTransition transition,
+ base::TimeTicks match_selection_timestamp,
+ bool url_typed_without_scheme,
+ bool url_typed_with_http_scheme)
+ : destination_url(destination_url),
+ disposition(disposition),
+ transition(transition),
+ match_selection_timestamp(match_selection_timestamp),
+ url_typed_without_scheme(url_typed_without_scheme),
+ url_typed_with_http_scheme(url_typed_with_http_scheme) {}
};
explicit LocationBar(CommandUpdater* command_updater)
OmniboxFieldTrial::IsChromeRefreshActionChipIconsEnabled()
? omnibox::kShareWinChromeRefreshIcon
: omnibox::kShareWinIcon;
-#elif BUILDFLAG(IS_LINUX)
+#elif BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
return OmniboxFieldTrial::IsChromeRefreshIconsEnabled() ||
OmniboxFieldTrial::IsChromeRefreshActionChipIconsEnabled()
? omnibox::kShareLinuxChromeRefreshIcon
struct MenuNotificationEntry {
int command = 0;
std::u16string label;
+ MenuNotificationEntry(int command, std::u16string label)
+ : command(command), label(label) {}
};
namespace {
// TODO(dfried, tbergquist): move this file down to c/b/ui if it's used outside
// of the tabstrip.
+#if !defined(EWK_BRINGUP) // FIXME: m120 bringup
#include <concepts>
+#endif
#include <cstdint>
#include <map>
+#include <type_traits>
#include "base/check.h"
#include "base/no_destructor.h"
// It is required that `T` derive from this class. This constraint is enforced
// via a helper class, as it cannot be enforced before SupportsHandles is
// defined.
-template <typename T, std::integral V = int32_t>
+template <typename T, typename V = int32_t>
class SupportsHandles {
+ static_assert(std::is_integral_v<V>);
+
public:
SupportsHandles();
virtual ~SupportsHandles();
//
// Unlike WeakPtr there is some overhead in looking up a handle, so convenience
// operators (bool, !, ->, *) are not provided.
-template <typename T, std::integral V>
+template <typename T, typename V>
class SupportsHandles<T, V>::Handle {
+ static_assert(std::is_integral_v<V>);
+
public:
Handle() = default;
Handle(const Handle& other) = default;
//
// This object is strictly sequence-checked and should only ever be accessed
// from the primary UI thread.
-template <typename T, std::integral V>
- requires std::derived_from<T, SupportsHandles<T, V>>
+template <typename T, typename V>
class HandleHelper {
+ static_assert(std::is_integral_v<V>);
+ static_assert(std::is_base_of_v<SupportsHandles<T, V>, T>);
+
public:
using StoredPointerType = SupportsHandles<T, V>*;
} // namespace internal
-template <typename T, std::integral V>
+template <typename T, typename V>
SupportsHandles<T, V>::SupportsHandles()
: handle_value_(
internal::HandleHelper<T, V>::GetInstance().AssignHandleValue(this)) {
+ static_assert(std::is_integral_v<V>);
}
-template <typename T, std::integral V>
+template <typename T, typename V>
SupportsHandles<T, V>::~SupportsHandles() {
+ static_assert(std::is_integral_v<V>);
internal::HandleHelper<T, V>::GetInstance().FreeHandleValue(handle_value_);
}
-template <typename T, std::integral V>
+template <typename T, typename V>
typename SupportsHandles<T, V>::Handle SupportsHandles<T, V>::GetHandle()
const {
+ static_assert(std::is_integral_v<V>);
return Handle(handle_value_);
}
-template <typename T, std::integral V>
+template <typename T, typename V>
T* SupportsHandles<T, V>::Handle::Get() const {
+ static_assert(std::is_integral_v<V>);
return internal::HandleHelper<T, V>::GetInstance().LookupObject(raw_value_);
}
struct RequestLineConfiguration {
const raw_ptr<const gfx::VectorIcon> icon;
std::u16string message;
+ RequestLineConfiguration(const raw_ptr<const gfx::VectorIcon> icon,
+ std::u16string message)
+ : icon(icon), message(message) {}
};
struct ButtonConfiguration {
std::u16string label;
ButtonType type;
ui::ButtonStyle style;
+ ButtonConfiguration(std::u16string label,
+ ButtonType type,
+ ui::ButtonStyle style)
+ : label(label), type(type), style(style) {}
};
static int GetViewId(ButtonType button) { return static_cast<int>(button); }
if (!IsHoverAnimationActive()) {
return base_opacity;
}
- return std::lerp(base_opacity, GetHoverOpacity(), GetHoverAnimationValue());
+ return std::lerp(static_cast<double>(base_opacity),
+ static_cast<double>(GetHoverOpacity()),
+ GetHoverAnimationValue());
}
TabActive GM2TabStyleViews::GetApparentActiveState() const {
if (!downloaded_icon_sizes.empty())
icon_size_ = *downloaded_icon_sizes.begin();
+#if !defined(EWK_BRINGUP) // FIXME : m120 bringup
result_.emplace();
+#else
+ result_ = Result();
+#endif
result_->has_empty_downloaded_icon_sizes = downloaded_icon_sizes.empty();
result_->has_generated_icon_flag = app_->is_generated_icon();
#elif BUILDFLAG(IS_WIN)
constexpr char kWinShareIconResourceName[] =
"//resources/cr_components/omnibox/icons/win_share.svg";
-#elif BUILDFLAG(IS_LINUX)
+#elif BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
constexpr char kLinuxShareIconResourceName[] =
"//resources/cr_components/omnibox/icons/share.svg";
#else
icon.name == omnibox::kShareWinChromeRefreshIcon.name) {
return kWinShareIconResourceName;
}
-#elif BUILDFLAG(IS_LINUX)
+#elif BUILDFLAG(IS_LINUX) && !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
if (icon.name == omnibox::kShareIcon.name ||
icon.name == omnibox::kShareLinuxChromeRefreshIcon.name) {
return kLinuxShareIconResourceName;
#include "build/build_config.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/url_constants.h"
+#if !defined(BUILD_CHROME)
#include "chrome/grit/sandbox_internals_resources.h"
#include "chrome/grit/sandbox_internals_resources_map.h"
+#endif
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_ui.h"
void CreateAndAddDataSource(Profile* profile) {
content::WebUIDataSource* source = content::WebUIDataSource::CreateAndAdd(
profile, chrome::kChromeUISandboxHost);
+#if !defined(BUILD_CHROME)
source->AddResourcePaths(base::make_span(kSandboxInternalsResources,
kSandboxInternalsResourcesSize));
source->SetDefaultResource(IDR_SANDBOX_INTERNALS_SANDBOX_INTERNALS_HTML);
+#endif
source->OverrideContentSecurityPolicy(
network::mojom::CSPDirectiveName::ScriptSrc,
});
}
-bool operator==(const UpdateManifest::VersionEntry& lhs,
- const UpdateManifest::VersionEntry& rhs) = default;
-
} // namespace web_app
base::Version version() const;
private:
- friend bool operator==(const VersionEntry& a, const VersionEntry& b);
+ friend bool operator==(const VersionEntry& a,
+ const VersionEntry& b) = default;
GURL src_;
base::Version version_;
UpdateManifest::VersionEntry GetLatestVersionEntry(
const UpdateManifest& update_manifest);
-bool operator==(const UpdateManifest::VersionEntry& lhs,
- const UpdateManifest::VersionEntry& rhs);
-
} // namespace web_app
#endif // CHROME_BROWSER_WEB_APPLICATIONS_ISOLATED_WEB_APPS_UPDATE_MANIFEST_UPDATE_MANIFEST_H_
return generated_icon_fix_;
}
-bool WebApp::IsolationData::PendingUpdateInfo::operator==(
- const WebApp::IsolationData::PendingUpdateInfo& other) const = default;
-bool WebApp::IsolationData::PendingUpdateInfo::operator!=(
- const WebApp::IsolationData::PendingUpdateInfo& other) const = default;
-
bool WebApp::operator==(const WebApp& other) const {
auto AsTuple = [](const WebApp& app) {
// Keep in order declared in web_app.h.
PendingUpdateInfo(const PendingUpdateInfo&);
PendingUpdateInfo& operator=(const PendingUpdateInfo&);
- bool operator==(const PendingUpdateInfo&) const;
- bool operator!=(const PendingUpdateInfo&) const;
+ bool operator==(const PendingUpdateInfo&) const = default;
+ bool operator!=(const PendingUpdateInfo&) const = default;
base::Value AsDebugValue() const;
friend std::ostream& operator<<(std::ostream& os,
const CredentialInfo&) = default;
AuthenticatorRequestDialogModel::Mechanism::CredentialInfo::~CredentialInfo() =
default;
-bool AuthenticatorRequestDialogModel::Mechanism::CredentialInfo::operator==(
- const CredentialInfo&) const = default;
void AuthenticatorRequestDialogModel::ResetEphemeralState() {
ephemeral_state_ = {};
std::vector<uint8_t> user_id_in);
CredentialInfo(const CredentialInfo&);
~CredentialInfo();
- bool operator==(const CredentialInfo&) const;
+ bool operator==(const CredentialInfo&) const = default;
const device::AuthenticatorType source;
const std::vector<uint8_t> user_id;
// org.tizen.browser, com.samsung.tv.knox-browser
// Only org.tizen.browser app need AutoLogin behavior according to their spec.
// The latter just wants Autofill.
+#if defined(BUILD_CHROME)
+ return false;
+#else
const std::string tizen_app_id =
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kTizenAppId);
return tizen_app_id == "org.tizen.browser";
+#endif
}
#endif
const std::string& custom_display_name)
: vendor_id(vendor_id), custom_display_name(custom_display_name) {}
-bool MediaType::operator==(const MediaType& other) const = default;
-
bool MediaType::IsValid() const {
return !vendor_id.empty();
}
MediaType(const std::string& vendor_id,
const std::string& custom_display_name);
- bool operator==(const MediaType& other) const;
+ bool operator==(const MediaType& other) const = default;
bool operator!=(const MediaType& other) const { return !(*this == other); }
bool IsValid() const;
char* argv[]) {
crashpad::UserStreamDataSources user_stream_data_sources;
-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
+#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && \
+ !BUILDFLAG(IS_TIZEN) // FIXME: m120 bringup
user_stream_data_sources.push_back(
std::make_unique<stability_report::UserStreamDataSourcePosix>());
#endif
}
bool HasCorrectLength(const std::string& number) {
- using enum CreditCardIssuer;
// Credit card numbers are at most 19 digits in length, 12 digits seems to
// be a fairly safe lower-bound [1]. Specific card issuers have more rigidly
// defined sizes.
}
const CreditCardIssuer type = GetCardNetwork(number);
- if (type == kGenericCard) {
+ if (type == CreditCardIssuer::kGenericCard) {
return true;
}
switch (number.size()) {
case 13:
- return type == kVisaCard;
+ return type == CreditCardIssuer::kVisaCard;
case 14:
- return type == kDinersCard;
+ return type == CreditCardIssuer::kDinersCard;
case 15:
- return type == kAmericanExpressCard;
+ return type == CreditCardIssuer::kAmericanExpressCard;
case 16:
- return (type == kDiscoverCard || type == kJCBCard ||
- type == kMasterCard || type == kMirCard || type == kTroyCard ||
- type == kUnionPay || type == kVisaCard);
+ return (type == CreditCardIssuer::kDiscoverCard ||
+ type == CreditCardIssuer::kJCBCard ||
+ type == CreditCardIssuer::kMasterCard ||
+ type == CreditCardIssuer::kMirCard ||
+ type == CreditCardIssuer::kTroyCard ||
+ type == CreditCardIssuer::kUnionPay ||
+ type == CreditCardIssuer::kVisaCard);
case 17:
[[fallthrough]];
case 18:
- return type == kUnionPay;
+ return type == CreditCardIssuer::kUnionPay;
case 19:
- return (type == kUnionPay || type == kVisaCard);
+ return (type == CreditCardIssuer::kUnionPay ||
+ type == CreditCardIssuer::kVisaCard);
default: {
return false;
}
#include "base/auto_reset.h"
#include "base/feature_list.h"
+#if BUILDFLAG(IS_TIZEN)
+#include "base/strings/utf_string_conversions.h"
+#include "base/trace_event/trace_event.h"
+#endif
#include "build/build_config.h"
#include "components/omnibox/browser/autocomplete_controller.h"
#include "components/omnibox/browser/autocomplete_input.h"
void SendForBatchExecution(
BatchExecutionCallback callback_on_complete,
base::TimeTicks start_time,
- ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs)
+ typename ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs)
override {
DCHECK(execution_task_runner_->RunsTasksInCurrentSequence());
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Starts the synchronous execution of the model. Returns model outputs.
// Model needs to be loaded. Synchronous calls do not load or unload model.
std::vector<absl::optional<OutputType>> SendForBatchExecutionSync(
- ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs)
+ typename ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs)
override {
DCHECK(execution_task_runner_->RunsTasksInCurrentSequence());
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// executes it on the model execution thread.
void LoadModelFileAndBatchExecute(
BatchExecutionCallback callback_on_complete,
- ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs) {
+ typename ModelExecutor<OutputType, InputType>::ConstRefInputVector
+ inputs) {
DCHECK(execution_task_runner_->RunsTasksInCurrentSequence());
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Batch executes the loaded model for inputs.
void BatchExecuteLoadedModel(
- ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs,
+ typename ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs,
std::vector<absl::optional<OutputType>>* outputs) {
DCHECK(execution_task_runner_->RunsTasksInCurrentSequence());
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Unloads the model if needed.
void BatchExecuteLoadedModelAndRunCallback(
BatchExecutionCallback callback_on_complete,
- ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs,
+ typename ModelExecutor<OutputType, InputType>::ConstRefInputVector inputs,
ExecutionStatus execution_status) {
DCHECK(execution_task_runner_->RunsTasksInCurrentSequence());
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
# TODO(b/269198471): Make sure the internal archive files for opt guide get
# updated when win arm64 gets added as a supported platform for TFLite.
build_with_tflite_lib = is_android || is_win || is_linux || is_mac ||
- is_chromeos || is_fuchsia || is_ios
+ is_chromeos || is_fuchsia || is_ios || is_tizen
}
declare_args() {
}
# TODO(crbug.com/1339022): Provide a Fuchsia-specific implementation.
- if ((is_posix && !is_apple && !(is_linux && !is_castos)) || is_fuchsia) {
+ if ((is_posix && !is_tizen && !is_apple && !(is_linux && !is_castos)) ||
+ is_fuchsia) {
sources += [ "os_crypt_posix.cc" ]
}
libs = [ "crypt32.lib" ]
}
- if (is_linux && !is_castos) {
+ if ((is_linux || is_tizen) && !is_castos) {
sources += [
"key_storage_config_linux.cc",
"key_storage_config_linux.h",
]
}
- if (is_win || is_mac || is_linux) {
+ if (is_win || is_mac || is_linux || is_tizen) {
sources += [
"cloud/profile_cloud_policy_manager.cc",
"cloud/profile_cloud_policy_manager.h",
} // namespace
Schema Schema::GetKnownProperty(const std::string& key) const {
+#if defined(BUILD_CHROME) // FIXME: Hotfix
+ return Schema();
+#endif
CHECK(valid());
CHECK_EQ(base::Value::Type::DICT, type());
const PropertiesNode* node = storage_->properties(node_->extra);
ldflags = [ "/DELAYLOAD:setupapi.dll" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"energy_metrics_provider_linux.cc",
"energy_metrics_provider_linux.h",
]
}
- if (is_win || is_linux || is_chromeos) {
+ if (is_win || is_linux || is_chromeos || is_tizen) {
sources += [
"system_power_monitor.cc",
"system_power_monitor.h",
namespace stability_report {
+#if !defined(BUILD_CHROME)
ProcessState& AddProcessForSnapshot(const base::ProcessId process_id,
StabilityReport* report) {
#if DCHECK_IS_ON()
process_state->set_process_id(process_id);
return *process_state;
}
+#endif
} // namespace stability_report
#define COMPONENTS_STABILITY_REPORT_USER_STREAM_DATA_SOURCE_H_
#include "base/process/process.h"
+#if !defined(BUILD_CHROME)
#include "components/stability_report/stability_report.pb.h"
+#endif
#include "third_party/crashpad/crashpad/handler/user_stream_data_source.h"
namespace crashpad {
ProduceStreamData(crashpad::ProcessSnapshot* process_snapshot) override = 0;
};
+#if !defined(BUILD_CHROME)
// Adds an entry for the given `process_id` to `report`.
ProcessState& AddProcessForSnapshot(const base::ProcessId process_id,
StabilityReport* report);
+#endif
} // namespace stability_report
StabilityReport report;
const base::ProcessId process_id = process_snapshot->ProcessID();
+#if !defined(BUILD_CHROME)
ProcessState& process_state = AddProcessForSnapshot(process_id, &report);
CollectFileDescriptorInfo(process_state, process_id);
+#endif
return std::make_unique<StabilityReportDataSource>(report);
}
]
deps += [ "//services/device/public/mojom" ]
}
- } else if (is_linux || is_chromeos_lacros) {
+ } else if (is_linux || is_chromeos_lacros || is_tizen) {
if (use_udev) {
sources += [
"mtab_watcher_linux.cc",
# Platforms which fully support supervision features:
is_android || is_chromeos ||
# Platforms for which support is currently in development:
- is_ios || is_linux || is_mac || is_win
+ is_ios || is_linux || is_mac || is_win || is_tizen
}
RetryingFetcherImpl(const RetryingFetcherImpl&) = delete;
RetryingFetcherImpl& operator=(const RetryingFetcherImpl&) = delete;
- void Start(ProtoFetcher<Response>::Callback callback) override {
+ void Start(typename ProtoFetcher<Response>::Callback callback) override {
callback_ = std::move(callback);
Retry();
}
}
// Client callback.
- ProtoFetcher<Response>::Callback callback_;
+ typename ProtoFetcher<Response>::Callback callback_;
// Retry controls.
base::OneShotTimer timer_;
template <typename Request, typename Response>
void ParallelFetchManager<Request, Response>::Fetch(
const Request& request,
- Fetcher::Callback callback) {
+ typename Fetcher::Callback callback) {
CHECK(callback) << "Use base::DoNothing() instead of empty callback.";
KeyType key = requests_in_flight_.Add(MakeFetcher(request));
requests_in_flight_.Lookup(key)->Start(
// Starts the fetch. Underlying fetcher is stored internally, and will be
// cleaned up after finish or when this manager is destroyed.
- void Fetch(const Request& request, Fetcher::Callback callback);
+ void Fetch(const Request& request, typename Fetcher::Callback callback);
private:
- using KeyType = base::IDMap<std::unique_ptr<Fetcher>>::KeyType;
+ using KeyType = typename base::IDMap<std::unique_ptr<Fetcher>>::KeyType;
// Remove fetcher under key from requests_in_flight_.
void Remove(KeyType key);
switches::kDiscardableMemoryLimit,
switches::kDiscardableMemoryPurgeDelay,
#endif
-#if BUILDFLAG(IS_TIZEN_TV)
+#if BUILDFLAG(IS_TIZEN_TV) && !defined(BUILD_CHROME)
switches::kTizenAppId,
#endif
};
void FakeRenderWidgetHost::SetCursor(const ui::Cursor& cursor) {}
+#if BUILDFLAG(IS_TIZEN_TV)
+void FakeRenderWidgetHost::DidEdgeScrollBy(const ::gfx::Point& offset,
+ bool handled) {}
+#endif
+
void FakeRenderWidgetHost::UpdateTooltipUnderCursor(
const std::u16string& tooltip_text,
base::i18n::TextDirection text_direction_hint) {}
// blink::mojom::WidgetHost overrides.
void SetCursor(const ui::Cursor& cursor) override;
+#if BUILDFLAG(IS_TIZEN_TV)
+ void DidEdgeScrollBy(const ::gfx::Point& offset, bool handled) override;
+#endif
void UpdateTooltipUnderCursor(
const std::u16string& tooltip_text,
base::i18n::TextDirection text_direction_hint) override;
%endif
install -m 0644 "%{OUTPUT_FOLDER}"/resources/*.edj "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/themes/
+
+%if %{__build_chrome} != 1
cp -r "%{OUTPUT_FOLDER}"/locale/* "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/locale/
chmod -R a=r,u+w,a+X "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/locale/*
+%endif
+
%if "%{?__use_system_icu}" != "1"
install -m 0644 "%{OUTPUT_FOLDER}"/icudtl.dat "%{buildroot}"%{CHROMIUM_LIB_DIR}/bin/
%endif
%define tizen_dist_sign 1
%endif
+%if %{__build_chrome} != 1
install -m 0644 "%{OUTPUT_FOLDER}"/images/*.png "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/images/
+%endif
+
install -m 0644 "%{OUTPUT_FOLDER}"/resources/*.edj "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/themes/
-cp -r "%{OUTPUT_FOLDER}"/locale/* "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/locale/
-chmod -R a=r,u+w,a+X "%{buildroot}"%{CHROMIUM_LIB_DIR}/res/locale/*
+
%if "%{?__use_system_icu}" != "1"
install -m 0644 "%{OUTPUT_FOLDER}"/icudtl.dat "%{buildroot}"%{CHROMIUM_LIB_DIR}/bin/
%endif
%{CHROMIUM_LIB_DIR}/bin/content_shell.pak
%{CHROMIUM_LIB_DIR}/bin/locales/*.pak
%{CHROMIUM_LIB_DIR}/res/themes/*.edj
-%{CHROMIUM_LIB_DIR}/res/images/*.png
%if %{__build_chrome} == 1
%{CHROMIUM_LIB_DIR}/bin/chrome_100_percent.pak
%else
%{CHROMIUM_LIB_DIR}/lib/libchromium-ewk.so
%endif
+ %{CHROMIUM_LIB_DIR}/res/images/*.png
%endif
-%{CHROMIUM_LIB_DIR}/res/themes/*.edj
%{CHROMIUM_LIB_DIR}/res/locale
%if "%{?__use_system_icu}" != "1"
# feature is enabled for the PDF viewer.
enable_ink = enable_cros_media_app
+#if !defined(BUILD_CHROME)
enable_pdf = !is_android && !is_ios && !is_castos
+#else
+ enable_pdf = !is_android && !is_ios && !is_castos && !is_tizen
+#endif
}
declare_args() {
# Enables printing support.
+#if defined(BUILD_CHROME)
+ enable_printing = !is_ios && !is_castos && !is_cast_android && !is_tizen
+#else
enable_printing = !is_ios && !is_castos && !is_cast_android
+#endif
# TODO(crbug.com/1432082): iOS blink port only enables printing_unittests for
# now because the port does not enable the printing feature yet.
std::unique_ptr<LocationProvider>
LocationArbitrator::NewSystemLocationProvider() {
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(BUILD_CHROME)
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableOffscreenRendering)) {
return device::NewSystemLocationProvider(main_task_runner_,
//! file.
//!
//! \sa MINIDUMP_STRING
-struct ALIGNAS(4) PACKED MinidumpUTF8String {
+struct PACKED MinidumpUTF8String {
// The field names do not conform to typical style, they match the names used
// in MINIDUMP_STRING. This makes it easier to operate on MINIDUMP_STRING (for
// UTF-16 strings) and MinidumpUTF8String using templates.
//! \brief A variable-length array of bytes carried within a minidump file.
//! The data have no intrinsic type and should be interpreted according
//! to their referencing context.
-struct ALIGNAS(4) PACKED MinidumpByteArray {
+struct PACKED MinidumpByteArray {
//! \brief The length of the #data field.
uint32_t length;
};
//! \brief A list of ::RVA pointers.
-struct ALIGNAS(4) PACKED MinidumpRVAList {
+struct PACKED MinidumpRVAList {
//! \brief The number of children present in the #children array.
uint32_t count;
};
//! \brief A key-value pair.
-struct ALIGNAS(4) PACKED MinidumpSimpleStringDictionaryEntry {
+struct PACKED MinidumpSimpleStringDictionaryEntry {
//! \brief ::RVA of a MinidumpUTF8String containing the key of a key-value
//! pair.
RVA key;
};
//! \brief A list of key-value pairs.
-struct ALIGNAS(4) PACKED MinidumpSimpleStringDictionary {
+struct PACKED MinidumpSimpleStringDictionary {
//! \brief The number of key-value pairs present.
uint32_t count;
};
//! \brief A typed annotation object.
-struct ALIGNAS(4) PACKED MinidumpAnnotation {
+struct PACKED MinidumpAnnotation {
//! \brief ::RVA of a MinidumpUTF8String containing the name of the
//! annotation.
RVA name;
};
//! \brief A list of annotation objects.
-struct ALIGNAS(4) PACKED MinidumpAnnotationList {
+struct PACKED MinidumpAnnotationList {
//! \brief The number of annotation objects present.
uint32_t count;
//! fields are valid or not.
//!
//! \sa MinidumpModuleCrashpadInfoList
-struct ALIGNAS(4) PACKED MinidumpModuleCrashpadInfo {
+struct PACKED MinidumpModuleCrashpadInfo {
//! \brief The structure’s currently-defined version number.
//!
//! \sa version
//! \brief A link between a MINIDUMP_MODULE structure and additional
//! Crashpad-specific information about a module carried within a minidump
//! file.
-struct ALIGNAS(4) PACKED MinidumpModuleCrashpadInfoLink {
+struct PACKED MinidumpModuleCrashpadInfoLink {
//! \brief A link to a MINIDUMP_MODULE structure in the module list stream.
//!
//! This field is an index into MINIDUMP_MODULE_LIST::Modules. This field’s
//! structure carried within the minidump file will necessarily have
//! Crashpad-specific information provided by a MinidumpModuleCrashpadInfo
//! structure.
-struct ALIGNAS(4) PACKED MinidumpModuleCrashpadInfoList {
+struct PACKED MinidumpModuleCrashpadInfoList {
//! \brief The number of children present in the #modules array.
uint32_t count;
//! structure. Revise #kVersion and document each field’s validity based on
//! #version, so that newer parsers will be able to determine whether the added
//! fields are valid or not.
-struct ALIGNAS(4) PACKED MinidumpCrashpadInfo {
+struct PACKED MinidumpCrashpadInfo {
// UUID has a constructor, which makes it non-POD, which makes this structure
// non-POD. In order for the default constructor to zero-initialize other
// members, an explicit constructor must be provided.
* This wraps C++20's std::construct_at, using placement new instead if it is not available.
*/
-#if EIGEN_COMP_CXXVER >= 20
+#if EIGEN_COMP_CXXVER >= 20 && !defined(EWK_BRINGUP) // FIXME: m120 bringup
using std::construct_at;
#else
template<class T, class... Args>
#else
template <typename T>
EIGEN_CONSTEXPR auto index_list_size(T&& x) {
+#if !defined(EWK_BRINGUP) // FIXME: m120 bringup
using std::ssize;
return ssize(std::forward<T>(x));
+#else
+ using std::size;
+ return size(std::forward<T>(x));
+#endif
}
#endif // EIGEN_COMP_CXXVER
#if defined(FLATBUFFERS_USE_STD_SPAN)
#include <array>
- #include <span>
+ #if !defined(EWK_BRINGUP) // FIXME: m120 bringup
+ #include <span>
+ #endif
#else
// Disable non-trivial ctors if FLATBUFFERS_SPAN_MINIMAL defined.
#if !defined(FLATBUFFERS_TEMPLATES_ALIASES)
// Very limited and naive partial implementation of C++20 std::span<T,Extent>.
-#if defined(FLATBUFFERS_USE_STD_SPAN)
+#if defined(FLATBUFFERS_USE_STD_SPAN) && !defined(EWK_BRINGUP) // FIXME: m120 bringup
inline constexpr std::size_t dynamic_extent = std::dynamic_extent;
template<class T, std::size_t Extent = std::dynamic_extent>
using span = std::span<T, Extent>;
};
#endif // defined(FLATBUFFERS_USE_STD_SPAN)
-#if !defined(FLATBUFFERS_SPAN_MINIMAL)
+#if !defined(FLATBUFFERS_SPAN_MINIMAL) && !defined(EWK_BRINGUP) // FIXME: m120 bringup
template<class ElementType, std::size_t Extent>
FLATBUFFERS_CONSTEXPR_CPP11
flatbuffers::span<ElementType, Extent> make_span(ElementType(&arr)[Extent]) FLATBUFFERS_NOEXCEPT {
} else {
m_pDevice->SetClip_PathFill(
*pPath, &mtObj2Device,
+#if !defined(EWK_BRINGUP) // FIXME: m120 bringup
CFX_FillRenderOptions(ClipPath.GetClipType(i)));
+#else
+ {.fill_type = ClipPath.GetClipType(i)});
+#endif
}
}
#endif
#if BUILDFLAG(IS_TIZEN_TV)
-#include "tizen_src/ewk/efl_integration/common/application_type.h"
+#include "third_party/blink/public/platform/web_application_type.h"
#endif
namespace ui {
// In non webapp scene,"Cancel" key haven't added on the map,the keycode is
// 0. "Cancel" key is delivered by IME, for hiding IME panel,no need deliver
// the key event. Or else,the keycode 0 may exception handling by website.
- if (!strcmp(key_down->key, "Cancel") && !content::IsTIZENWRT())
+ if (!strcmp(key_down->key, "Cancel") && !blink::IsTIZENWRT())
return;
}
#endif
// In non webapp scene,"Cancel" key haven't added on the map,the keycode is
// 0. "Cancel" key is delivered by IME, for hiding IME panel,no need deliver
// the key event. Or else,the keycode 0 may exception handling by website.
- if (!strcmp(key_up->key, "Cancel") && !content::IsTIZENWRT())
+ if (!strcmp(key_up->key, "Cancel") && !blink::IsTIZENWRT())
return;
#endif
}
was_up_keypress_on_ime_top_ = false;
}
- if (content::IsWebBrowser() || content::IsTIZENWRT()) {
+ if (blink::IsWebBrowser() || blink::IsTIZENWRT()) {
evt->keyname = (char*)"Cancel"; /*Return Back key name*/
evt->key = (char*)"Cancel"; /*Return Back key*/
evt->string = (char*)""; /*Return Back string*/
#include "ui/ozone/platform/efl/efl_window.h"
#if BUILDFLAG(IS_TIZEN_TV)
-#include "tizen_src/ewk/efl_integration/common/application_type.h"
+#include "third_party/blink/public/platform/web_application_type.h"
#endif
#ifdef IM_CTX_DEBUG
#if BUILDFLAG(IS_TIZEN_TV)
// 2017 WebBrowser App want no recommended list same as 2015, 2016.
- if (content::IsWebBrowser())
+ if (blink::IsWebBrowser())
allow_prediction = false;
// Always enable "Up" and "Down" key
event.set_key_code(static_cast<KeyboardCode>(229));
#if BUILDFLAG(IS_TIZEN_TV)
- if (content::IsTIZENWRT()) {
+ if (blink::IsTIZENWRT()) {
// a-z, A-Z, 0-9
int key_code = event.key_code();
if ((key_code >= 65 && key_code <= 90) ||
namespace ui::wayland {
// A 2.4 gamma for the BT2087 transfer function.
-static constexpr skcms_TransferFunction gamma24 = {2.4f, 1.f};
-constexpr uint32_t kDefaultSinceVersion = 1;
+static const skcms_TransferFunction gamma24 = {2.4f, 1.f};
+const uint32_t kDefaultSinceVersion = 1;
// These structs are used for holding ColorSpace enums, and the version of the
// color management protocol their support was introduced.
struct TransferFnVersion {
skcms_TransferFunction transfer_fn;
uint32_t version;
+ TransferFnVersion(skcms_TransferFunction transfer_fn, uint32_t version)
+ : transfer_fn(transfer_fn), version(version) {}
};
struct TransferVersion {
gfx::ColorSpace::TransferID transfer;
uint32_t version;
+ TransferVersion(gfx::ColorSpace::TransferID transfer, uint32_t version)
+ : transfer(transfer), version(version) {}
};
struct PrimaryVersion {
gfx::ColorSpace::PrimaryID primary;
uint32_t version;
+ PrimaryVersion(gfx::ColorSpace::PrimaryID primary, uint32_t version)
+ : primary(primary), version(version) {}
};
struct MatrixVersion {
gfx::ColorSpace::MatrixID matrix;
uint32_t version;
+ MatrixVersion(gfx::ColorSpace::MatrixID matrix, uint32_t version)
+ : matrix(matrix), version(version) {}
};
struct RangeVersion {
gfx::ColorSpace::RangeID range;
uint32_t version;
+ RangeVersion(gfx::ColorSpace::RangeID range, uint32_t version)
+ : range(range), version(version) {}
};
// A map from the zcr_color_manager_v1 chromaticity_names enum values
// representing well-known chromaticities, to their equivalent PrimaryIDs.
// See components/exo/wayland/protocol/chrome-color-management.xml
-constexpr auto kChromaticityMap = base::MakeFixedFlatMap<
+const auto kChromaticityMap = base::MakeFixedFlatMap<
zcr_color_manager_v1_chromaticity_names,
PrimaryVersion>(
{{ZCR_COLOR_MANAGER_V1_CHROMATICITY_NAMES_BT601_525_LINE,
// A map from the zcr_color_manager_v1 eotf_names enum values
// representing well-known EOTFs, to their equivalent TransferIDs.
// See components/exo/wayland/protocol/chrome-color-management.xml
-constexpr auto kEotfMap = base::MakeFixedFlatMap<
- zcr_color_manager_v1_eotf_names,
- TransferVersion>({
+const auto kEotfMap = base::MakeFixedFlatMap<zcr_color_manager_v1_eotf_names,
+ TransferVersion>({
{ZCR_COLOR_MANAGER_V1_EOTF_NAMES_LINEAR,
TransferVersion(gfx::ColorSpace::TransferID::LINEAR,
kDefaultSinceVersion)},
// A map from the SDR zcr_color_manager_v1 eotf_names enum values
// representing well-known EOTFs, to their equivalent transfer functions.
// See components/exo/wayland/protocol/chrome-color-management.xml
-constexpr auto kTransferMap =
+const auto kTransferMap =
base::MakeFixedFlatMap<zcr_color_manager_v1_eotf_names, TransferFnVersion>({
{ZCR_COLOR_MANAGER_V1_EOTF_NAMES_LINEAR,
TransferFnVersion(SkNamedTransferFn::kLinear, kDefaultSinceVersion)},
// A map from the HDR zcr_color_manager_v1 eotf_names enum values
// representing well-known EOTFs, to their equivalent transfer functions.
// See components/exo/wayland/protocol/chrome-color-management.xml
-constexpr auto kHDRTransferMap =
+const auto kHDRTransferMap =
base::MakeFixedFlatMap<zcr_color_manager_v1_eotf_names, TransferFnVersion>(
{{ZCR_COLOR_MANAGER_V1_EOTF_NAMES_LINEAR,
TransferFnVersion(SkNamedTransferFn::kLinear, kDefaultSinceVersion)},
// A map from zcr_color_manager_v1 matrix_names enum values to
// gfx::ColorSpace::MatrixIDs.
-constexpr auto kMatrixMap =
+const auto kMatrixMap =
base::MakeFixedFlatMap<zcr_color_manager_v1_matrix_names, MatrixVersion>(
{{ZCR_COLOR_MANAGER_V1_MATRIX_NAMES_RGB,
MatrixVersion(gfx::ColorSpace::MatrixID::RGB, kDefaultSinceVersion)},
// A map from zcr_color_manager_v1 range_names enum values to
// gfx::ColorSpace::RangeIDs.
-constexpr auto kRangeMap =
+const auto kRangeMap =
base::MakeFixedFlatMap<zcr_color_manager_v1_range_names, RangeVersion>(
{{ZCR_COLOR_MANAGER_V1_RANGE_NAMES_LIMITED,
RangeVersion(gfx::ColorSpace::RangeID::LIMITED,
} // namespace ui::wayland
-#endif // UI_BASE_WAYLAND_COLOR_MANAGER_UTIL_H_
\ No newline at end of file
+#endif // UI_BASE_WAYLAND_COLOR_MANAGER_UTIL_H_
"//ui/platform_window/wm",
]
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"host/linux_ui_delegate_wayland.cc",
"host/linux_ui_delegate_wayland.h",
]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"host/wayland_async_cursor.cc",
"host/wayland_async_cursor.h",
projects / platform / framework / web / chromium-efl.git / commitdiff