]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"debug/proc_maps_linux.cc",
"debug/proc_maps_linux.h",
}
# Linux.
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
# TODO(brettw) this will need to be parameterized at some point.
linux_configs = []
if (use_glib) {
ldflags += [ "-Wl,-mllvm,-import-instr-limit=$import_instr_limit" ]
- if (!is_chromeos) {
+ # TODO: Need to check if flag is supported by clang 11
+ if (!is_chromeos && !is_tizen) {
# TODO(https://crbug.com/972449): turn on for ChromeOS when that
# toolchain has this flag.
# We only use one version of LLVM within a build so there's no need to
libs = [ "resolv" ]
}
-if (use_glib) {
+if (use_glib || is_tizen) {
pkg_config("glib") {
packages = [
"glib-2.0",
assert(!use_glib || (is_linux && !is_castos))
-use_atk =
- is_tizen || (use_glib && !use_efl && current_toolchain == default_toolchain)
+use_atk = use_glib && !use_efl && current_toolchain == default_toolchain
# Whether using Xvfb to provide a display server for a test might be
# necessary.
[ official_name ],
"trim string",
[ lastchange_file ])
+
+# FIXME(bringup 114) need to track how trailing characters appended to
+# build_timestamp for tizen case.
+build_timestamp = "1684110627"
#include "cc/trees/proxy_common.h"
#if BUILDFLAG(IS_TIZEN)
-#include "base/callback.h"
+#include "base/functional/callback_forward.h"
#endif
namespace cc {
const char* const features[],
size_t number_of_features) {
DCHECK(features);
-
+#if !defined(EWK_BRINGUP)
for (unsigned i = 0; i < element.AttributeCount(); ++i) {
std::string filtered_value =
base::ToLowerASCII(element.AttributeValue(i).Utf8());
return true;
}
}
+#endif
return false;
}
#if defined(TIZEN_AUTOFILL)
// TODO(djmix.kim) : This is a temporary solution for tct.
// It will be removed after integrating autofill_profile_validator_factory.
- database_helper_->GetLocalDatabase()->RemoveAutofillProfile(guid);
+ database_helper_->GetLocalDatabase()->RemoveAutofillProfile(
+ guid, AutofillProfile::Source::kLocalOrSyncable);
#else
RemoveProfileFromDB(guid);
#endif
#include "base/notreached.h"
#include "base/sanitizer_buildflags.h"
+#include "base/strings/string_piece.h"
#include "build/branding_buildflags.h"
#include "build/build_config.h"
#include "components/version_info/channel.h"
const std::string& build_version);
// Returns the product name, e.g. "Chromium" or "Google Chrome".
-constexpr std::string GetProductName() {
+constexpr base::StringPiece GetProductName() {
return PRODUCT_NAME;
}
// Returns the version number, e.g. "6.0.490.1".
-constexpr std::string GetVersionNumber() {
+constexpr base::StringPiece GetVersionNumber() {
return PRODUCT_VERSION;
}
// Returns the product name and version information for the User-Agent header,
// in the format: Chrome/<major_version>.<minor_version>.<build>.<patch>.
-constexpr std::string GetProductNameAndVersionForUserAgent() {
- return "Chrome/" + GetVersionNumber();
+constexpr base::StringPiece GetProductNameAndVersionForUserAgent() {
+ return "Chrome/" PRODUCT_VERSION;
}
// Returns the major component (aka the milestone) of the version as an int,
const base::Version& GetVersion();
// Returns a version control specific identifier of this release.
-constexpr std::string GetLastChange() {
+constexpr base::StringPiece GetLastChange() {
return LAST_CHANGE;
}
}
// Returns the OS type, e.g. "Windows", "Linux", "FreeBSD", ...
-constexpr std::string GetOSType() {
+constexpr base::StringPiece GetOSType() {
#if BUILDFLAG(IS_WIN)
return "Windows";
#elif BUILDFLAG(IS_IOS)
// Returns a string equivalent of |channel|, independent of whether the build
// is branded or not and without any additional modifiers.
-constexpr std::string GetChannelString(Channel channel) {
+constexpr base::StringPiece GetChannelString(Channel channel) {
switch (channel) {
case Channel::STABLE:
return "stable";
}
// Returns a list of sanitizers enabled in this build.
-constexpr std::string GetSanitizerList() {
+constexpr base::StringPiece GetSanitizerList() {
return ""
#if defined(ADDRESS_SANITIZER)
"address "
# Not Mac.
deps += [ "//sandbox" ]
}
- if (is_tizen) {
- deps -= [ "//content/browser/tracing:resources" ]
- }
# Desktop/Window/WebContents screen capture implementations, conditionally
# built depending on the available implementations for each platform.
]
}
- if (is_android || is_linux || is_chromeos) {
+ if (is_android || is_linux || is_chromeos || is_tizen) {
deps += [ "//content/browser/system_dns_resolution" ]
}
#include "content/browser/date_time_chooser_efl.h"
#endif
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
#include "tizen_src/chromium_impl/components/xwalk_extensions/browser/xwalk_extension_manager.h"
#endif
host->GetAncestorRenderFrameHostId(),
RenderProcessHost::NotificationServiceCreatorType::kDedicatedWorker,
host));
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
map->Add<wrt::mojom::XWalkExtensionBrowser>(base::BindRepeating(
&wrt::XWalkExtensionManager::Bind));
#endif
BrowserAccessibilityManager*
RenderFrameHostImpl::GetOrCreateBrowserAccessibilityManager() {
+#if defined(EWK_BRINGUP)
+ LOG(ERROR) << " Need to enable BrowserAccessibilityManager for Tizen";
+ return nullptr;
+#endif
// Never create a BrowserAccessibilityManager unless needed for the AXMode.
// At least basic mode is required; it contains kWebContents and KNativeAPIs.
ui::AXMode accessibility_mode = delegate_->GetAccessibilityMode();
// static
TtsPlatform* TtsPlatform::GetInstance() {
+#if defined(EWK_BRINGUP)
+ LOG(ERROR) << " Need to enable tts for Tizen";
+ return nullptr;
+#endif
#if !defined(NO_CONTENT_CLIENT)
TtsPlatform* result = GetContentClient()->browser()->GetTtsPlatform();
if (result)
import("//build/buildflag_header.gni")
-if (is_android || is_linux || is_chromeos) {
+if (is_android || is_linux || is_chromeos || is_tizen) {
# //net/dns "friends" this target (so these source files can include private
# headers from //net/dns).
source_set("system_dns_resolution") {
std::string WebContentsImpl::DumpAccessibilityTree(
bool internal,
std::vector<ui::AXPropertyFilter> property_filters) {
+#if !defined(EWK_BRINGUP)
OPTIONAL_TRACE_EVENT0("content", "WebContentsImpl::DumpAccessibilityTree");
auto* ax_mgr = GetOrCreateRootBrowserAccessibilityManager();
// Since for Web Content we get the AXTree updates through the renderer at a
formatter->SetPropertyFilters(property_filters);
return formatter->Format(ax_mgr->GetBrowserAccessibilityRoot());
+#else
+ return " ";
+#endif
}
void WebContentsImpl::RecordAccessibilityEvents(
bool start_recording,
absl::optional<ui::AXEventCallback> callback) {
+#if defined(EWK_BRINGUP)
+ LOG(ERROR) << " Need to enable for Tizen";
+ return;
+#else
OPTIONAL_TRACE_EVENT0("content",
"WebContentsImpl::RecordAccessibilityEvents");
event_recorder_.reset(nullptr);
}
}
+#endif
}
device::mojom::GeolocationContext* WebContentsImpl::GetGeolocationContext() {
uint32_t shim_texture_pool_size = media::limits::kMaxVideoFrames + 1;
shim_texture_pool_size =
std::max(shim_texture_pool_size, min_picture_count_);
+#if !defined(EWK_BRINGUP)
auto new_decoder = VideoDecoderShim::Create(this, shim_texture_pool_size,
/*use_hw_decoder=*/true);
if (new_decoder &&
mojo_video_decoder_path_initialized_ = true;
return PP_OK;
}
+#endif
}
decoder_.reset();
if (acceleration == PP_HARDWAREACCELERATION_ONLY)
ScopedAllowBlockingForNSS allow_blocking;
EnsureNSPRInit();
-
+#if BUILDFLAG(IS_TIZEN)
+ LOG(INFO) << " Tizen 8.0 platform NSS library version is 3.34 and open "
+ "source expects 3.35 or higher";
+#else
// We *must* have NSS >= 3.35 at compile time.
static_assert((NSS_VMAJOR == 3 && NSS_VMINOR >= 35) || (NSS_VMAJOR > 3),
"nss version check failed");
"still get this error, contact your distribution "
"maintainer.";
}
+#endif
SECStatus status = SECFailure;
base::FilePath database_dir = GetInitialConfigDirectory();
#include "gpu/ipc/common/gpu_memory_buffer_impl_native_pixmap.h"
#if BUILDFLAG(IS_TIZEN)
-#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan.h"
+#include "third_party/swiftshader/include/vulkan/vulkan.h"
#else
#include <vulkan/vulkan.h>
#endif
#include "build/build_config.h"
#if BUILDFLAG(IS_TIZEN)
-#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#include "third_party/swiftshader/include/vulkan/vulkan_core.h"
#else
#include <vulkan/vulkan_core.h>
#endif
// Please update UMA histogram enumeration when adding new formats here.
#if BUILDFLAG(IS_TIZEN)
- PIXEL_FORMAT_ENCODED = 39, // encoded pixels, 1 plane
+ PIXEL_FORMAT_ENCODED = 40, // encoded pixels, 1 plane
#if defined(TIZEN_TBM_SUPPORT)
- PIXEL_FORMAT_TBM_SURFACE = 40,
- PIXEL_FORMAT_TBM_INTER_PROCESS_BUFFER = 41,
+ PIXEL_FORMAT_TBM_SURFACE = 41,
+ PIXEL_FORMAT_TBM_INTER_PROCESS_BUFFER = 42,
PIXEL_FORMAT_MAX = PIXEL_FORMAT_TBM_INTER_PROCESS_BUFFER,
#else
PIXEL_FORMAT_MAX =
source_set("sandbox") {
sources = []
- if (is_linux || is_chromeos_ash) {
+ if (is_linux || is_chromeos_ash || is_tizen) {
sources += [
"hardware_video_decoding_sandbox_hook_linux.cc",
"hardware_video_decoding_sandbox_hook_linux.h",
]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"hardware_video_encoding_sandbox_hook_linux.cc",
"hardware_video_encoding_sandbox_hook_linux.h",
}
enabled_features = []
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "is_linux_or_chromeos" ]
}
[ "//chromeos/components/cdm_factory_daemon:cdm_factory_daemon_gpu" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"mojo_video_encode_accelerator_provider_factory.cc",
"mojo_video_encode_accelerator_provider_factory.h",
]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"base/address_map_cache_linux.cc",
"base/address_map_cache_linux.h",
}
}
- if (is_android || is_chromeos || is_linux) {
+ if (is_android || is_chromeos || is_linux || is_tizen) {
sources += [
"base/network_change_notifier_passive.cc",
"base/network_change_notifier_passive.h",
void QuicChromiumClientSession::MigrateToMultiPortPath(
std::unique_ptr<quic::QuicPathValidationContext> context) {
+#if !defined(EWK_BRINGUP)
DCHECK_NE(nullptr, context);
+#endif
auto* chrome_context =
static_cast<QuicChromiumPathValidationContext*>(context.get());
std::unique_ptr<QuicChromiumPacketWriter> owned_writer =
Summary: Chromium EFL
# Version: {TPK_VERSION}.{INTERNAL_API_REVISION}.{CHROMIUM_MAJOR_VERSION}
# The {INTERNAL_API_REVISION} is used for compatibility check with wrtjs.
-Version: 1.1.108
+Version: 1.1.114
# Set by ./tizen_src/scripts/update_chromium_version.sh
-%define upstream_chromium_version 108.0.5359.1
+%define upstream_chromium_version 114.0.5735.31
Release: 1
# The 'Group' should be specified as one of the following valid group list.
# https://wiki.tizen.org/wiki/Packaging/Guidelines#Group_Tag
%endif
%define __enable_ewk_interface 1
-
+%define __enable_wrt_js 0
# Enable to support squashfs RPM and image by default
%define __enable_squashfs_image 1
%if "%{?profile}" == "tv" && "%{_vd_cfg_chip_vendor}" == "EMUL"
install -m 0755 "%{OUTPUT_FOLDER}"/libminigbm.so "%{buildroot}"%{_libdir}
%else
install -m 0644 "%{OUTPUT_FOLDER}"/locales/efl/*.pak "%{buildroot}"%{CHROMIUM_LIB_DIR}/bin/locales/
-
+ install -m 0755 "%{OUTPUT_FOLDER}"/libtest_trace_processor.so "%{buildroot}"%{_libdir}
install -m 0755 "%{OUTPUT_FOLDER}"/efl_webprocess "%{buildroot}"%{_bindir}/
%if "%{?profile}" == "tv"
ln -s efl_webprocess "%{buildroot}"%{_bindir}/efl_pluginprocess
%{_libdir}/libminigbm.so
%else
%{_libdir}/libchromium-ewk.so
+ %{_libdir}/libtest_trace_processor.so
%{_libdir}/libewebkit2.so*
%if 0%{?__enable_squashfs_image}
%if "%{?tizen_profile_name}" == "tv"
namespace {
-std::unique_ptr<base::Value> ValueFromVarArray(const PP_Var& var) {
+std::unique_ptr<base::Value::List> ValueFromVarArray(const PP_Var& var) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
if (var.type == PP_VARTYPE_ARRAY) {
scoped_refptr<ArrayVar> array =
scoped_refptr<ArrayVar>(ArrayVar::FromPPVar(var));
}
return std::move(ret);
}
-
- return std::make_unique<base::Value>();
+#endif
+ return std::make_unique<base::Value::List>();
}
-std::unique_ptr<base::Value> ValueFromVarDictionary(const PP_Var& var) {
+std::unique_ptr<base::Value::Dict> ValueFromVarDictionary(const PP_Var& var) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
if (var.type == PP_VARTYPE_DICTIONARY) {
scoped_refptr<DictionaryVar> dict =
scoped_refptr<DictionaryVar>(DictionaryVar::FromPPVar(var));
}
return std::move(ret);
}
-
- return std::make_unique<base::Value>();
+#endif
+ return std::make_unique<base::Value::Dict>();
}
ScopedPPVar VarFromValueArray(const base::Value* value) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
if (!value)
return ScopedPPVar();
return ScopedPPVar(ScopedPPVar::PassRef(), ret->GetPPVar());
}
-
+#endif
return ScopedPPVar();
}
ScopedPPVar VarFromValueDictionary(const base::Value* value) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
if (!value)
return ScopedPPVar();
}
return ScopedPPVar(ScopedPPVar::PassRef(), ret->GetPPVar());
}
-
+#endif
return ScopedPPVar();
}
} // namespace
std::unique_ptr<base::Value> ValueFromVar(const PP_Var& var) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
switch (var.type) {
case PP_VARTYPE_BOOL:
return std::make_unique<base::Value>(PP_ToBool(var.value.as_bool));
default:
return std::make_unique<base::Value>();
}
+#endif
+ return std::make_unique<base::Value>();
}
ScopedPPVar VarFromValue(const base::Value* value) {
+#if !defined(EWK_BRINGUP)
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
if (!value)
return ScopedPPVar();
default:
return ScopedPPVar();
}
+#endif
+ return ScopedPPVar();
}
} // namespace proxy
compile_credentials = is_linux || is_chromeos || is_tizen
- compile_syscall_broker = is_linux || is_chromeos
+ compile_syscall_broker = is_linux || is_chromeos || is_tizen
# On Android, use plain GTest.
use_base_test_suite = is_linux || is_chromeos
"linux/sandbox_seccomp_bpf_linux.cc",
"linux/sandbox_seccomp_bpf_linux.h",
]
- if (is_linux || is_chromeos_ash) {
+ if (is_linux || is_chromeos_ash || is_tizen) {
sources += [
"linux/bpf_hardware_video_decoding_policy_linux.cc",
"linux/bpf_hardware_video_decoding_policy_linux.h",
#include "sandbox/policy/linux/bpf_hardware_video_decoding_policy_linux.h"
+#if BUILDFLAG(IS_TIZEN_TV)
#include <linux/kcmp.h>
+#endif
#include "media/gpu/buildflags.h"
#include "sandbox/linux/seccomp-bpf-helpers/sigsys_handlers.h"
return Allow();
case __NR_sched_setaffinity:
return RestrictSchedTarget(GetPolicyPid(), system_call_number);
+#if BUILDFLAG(IS_TIZEN_TV)
case __NR_kcmp: {
const Arg<pid_t> pid1(0);
const Arg<pid_t> pid2(1);
Allow())
.Else(Error(EPERM));
}
+#endif
}
auto* sandbox_linux = SandboxLinux::GetInstance();
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/sockios.h>
+#include <sys/socket.h>
#include <linux/wireless.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/inotify.h>
#include <sys/mman.h>
-#include <sys/socket.h>
#include <unistd.h>
#include "base/feature_list.h"
if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "has_zygote" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "is_linux_or_chromeos" ]
}
if (is_linux || is_chromeos_ash || is_tizen) {
]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"network_change_notifier_passive_factory.cc",
"network_change_notifier_passive_factory.h",
net::NetworkChangeNotifierPassive* notifier =
static_cast<net::NetworkChangeNotifierPassive*>(
network_change_notifier_.get());
-
+#if !defined(EWK_BRINGUP)
notifier->GetAddressMapOwner()->GetAddressMapCacheLinux()->ApplyDiffs(
change_params->address_map, change_params->online_links);
+#endif
}
#endif // BUILDFLAG(IS_LINUX)
sources += [ "transferable_directory_fuchsia.cc" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"network_interface_change_listener_mojom_traits.cc",
"network_interface_change_listener_mojom_traits.h",
}
enabled_features = []
- if (is_android || is_chromeos || is_linux) {
+ if (is_android || is_chromeos || is_linux || is_tizen) {
enabled_features += [ "network_change_notifier_in_browser" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
# TODO(crbug.com/1431866): Remove this once is_linux in the mojom IDL does
# not include lacros.
enabled_features += [ "use_network_interface_change_listener" ]
},
]
- if (is_linux) {
+ if (is_linux || is_tizen) {
cpp_typemaps += [
{
types = [
}
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
# TODO(crbug.com/1431866): Remove this once is_linux in the mojom IDL does
# not include lacros.
enabled_features += [ "use_network_interface_change_listener" ]
}
RecordSCTAuditingReportDeduplicatedMetrics(false);
- report->set_user_agent(version_info::GetProductNameAndVersionForUserAgent());
+ report->set_user_agent(
+ std::string(version_info::GetProductNameAndVersionForUserAgent()));
// Add `cache_key` to the dedupe cache. The cache value is not used.
dedupe_cache_.Put(cache_key, true);
int64_t usage,
int64_t quota,
bool policy_changed) {
- if (policy_changed)
+ LOG(ERROR) << " Remove with EWK_BRINGUP ";
+ if (policy_changed) {
+#if !defined(EWK_BRINGUP)
GetUsageAndQuota(StorageKey(url::Origin::Create(origin)),
StorageType::kTemporary, std::move(callback));
- else
+#endif
+ } else
std::move(callback).Run(status, usage, quota);
}
#endif
#include <stddef.h>
#include <unordered_set>
-
#include "base/lazy_instance.h"
+#include "base/logging.h"
#include "base/strings/string_util.h"
#include "build/build_config.h"
#include "media/media_buildflags.h"
#if BUILDFLAG(IS_TIZEN_TV)
void MimeUtil::RegisterJavascriptPluginMimeTypes(
const std::string& mime_types) {
+ LOG(ERROR) << " Remove EWK_BRINGUP ";
+#if !defined(EWK_BRINGUP)
std::stringstream stream(mime_types);
std::string mime_type;
while (std::getline(stream, mime_type, ','))
javascript_plugin_types_.insert(base::ToLowerASCII(mime_type));
+#endif
}
bool MimeUtil::IsSupportedJavascriptPluginMimeType(
"xr_camera.h",
"xr_canvas_input_provider.cc",
"xr_canvas_input_provider.h",
+ "xr_composition_layer.cc",
+ "xr_composition_layer.h",
"xr_cpu_depth_information.cc",
"xr_cpu_depth_information.h",
"xr_cube_map.cc",
"xr_plane_set.h",
"xr_pose.cc",
"xr_pose.h",
+ "xr_projection_layer.cc",
+ "xr_projection_layer.h",
"xr_ray.cc",
"xr_ray.h",
"xr_reference_space.cc",
const T&... values) {
std::string strkey = std::string(key);
- if constexpr (Flags & kEncrypted) {
+ if (Flags & kEncrypted) {
if (is_encrypted_)
UmaFunction(strkey + ".EME", values...);
}
- if constexpr (Flags & kTotal)
+ if (Flags & kTotal)
UmaFunction(strkey + ".All", values...);
- if constexpr (Flags & kPlaybackType) {
+ if (Flags & kPlaybackType) {
auto demuxer_type = GetDemuxerType();
if (!demuxer_type.has_value())
return;
return result;
}
- [[nodiscard]] static constexpr AffineTransform MakeSkewX(double angle) {
+ [[nodiscard]] static AffineTransform MakeSkewX(double angle) {
return AffineTransform(1, 0, std::tan(Deg2rad(angle)), 1, 0, 0);
}
- [[nodiscard]] static constexpr AffineTransform MakeSkewY(double angle) {
+ [[nodiscard]] static AffineTransform MakeSkewY(double angle) {
return AffineTransform(1, std::tan(Deg2rad(angle)), 0, 1, 0, 0);
}
[[nodiscard]] static constexpr AffineTransform Translation(double x,
#define VK_KHR_video_decode_h264 1
-#include "vk_video/vulkan_video_codec_h264std.h"
-#include "vk_video/vulkan_video_codec_h264std_decode.h"
+#include "third_party/swiftshader/include/vk_video/vulkan_video_codec_h264std.h"
+#include "third_party/swiftshader/include/vk_video/vulkan_video_codec_h264std_decode.h"
#define VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION 8
#define VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME "VK_KHR_video_decode_h264"
#define VK_KHR_video_decode_h265 1
-#include "vk_video/vulkan_video_codec_h265std.h"
-#include "vk_video/vulkan_video_codec_h265std_decode.h"
+#include "third_party/swiftshader/include/vk_video/vulkan_video_codec_h265std.h"
+#include "third_party/swiftshader/include/vk_video/vulkan_video_codec_h265std_decode.h"
#define VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION 7
#define VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME "VK_KHR_video_decode_h265"
typedef struct VkVideoDecodeH265ProfileInfoKHR {
deps_include_path,
# find / -name *.h -printf '%h\n' | sort --unique
+ "$deps_include_path/atk-1.0",
"$deps_include_path/dbus-1.0",
"$deps_include_path/ecore-1",
"$deps_include_path/ecore-audio-1",
}
if (is_tizen) {
- tizen_autofill = true
+ tizen_autofill = false
if (tizen_product_tv) {
- tizen_autofill_fw = true
+ tizen_autofill_fw = false
}
}
if [ "$tizen_product_tv" == "true" ]; then
ADDITIONAL_GN_PARAMETERS+="enable_plugins=true
use_plugin_placeholder_hole=true
+ use_atk=false
"
fi
- ADDITIONAL_GN_PARAMETERS+="tizen_multimedia=true
+ ADDITIONAL_GN_PARAMETERS+="tizen_multimedia=false
proprietary_codecs=true
- tizen_audio_io=true
- tizen_web_speech_recognition=true
- tizen_tbm_support=true
+ tizen_audio_io=false
+ tizen_web_speech_recognition=false
+ tizen_tbm_support=false
"
if [ "$tizen_product_tv" == "true" ]; then
- ADDITIONAL_GN_PARAMETERS+="tizen_pepper_extensions=true
+ ADDITIONAL_GN_PARAMETERS+="tizen_pepper_extensions=false
"
fi
# Enable video hole only for standard and TV profile
if [ \( "$tizen_product_tv" == "true" \) -o \( "$tizen_product_da" != "true" -a "$tizen_emulator_support" != "true" \) ]; then
- ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=true
+ ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=false
"
else
ADDITIONAL_GN_PARAMETERS+="tizen_video_hole=false
#include "base/functional/callback.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
+#include "base/task/single_thread_task_runner.h"
#include "base/threading/thread_checker.h"
#include "services/device/public/cpp/generic_sensor/sensor_reading.h"
#include "services/device/public/mojom/sensor.mojom.h"
}
LocationProviderEfl::LocationProviderEfl()
- : location_manager_(nullptr),
- task_runner_(base::SingleThreadTaskRunner::GetCurrentDefault()) {}
+ : location_manager_(nullptr)
+#if !defined(EWK_BRINGUP)
+ ,
+ task_runner_(base::SingleThreadTaskRunner::GetCurrentDefault())
+#endif
+{
+}
LocationProviderEfl::~LocationProviderEfl() {
StopProvider();
timestamp);
}
void LocationProviderEfl::NotifyCallback(const mojom::Geoposition& position) {
+#if !defined(EWK_BRINGUP)
if (!callback_.is_null())
callback_.Run(this, position);
+#endif
}
void LocationProviderEfl::SetUpdateCallback(
double direction,
double horizontal_accuracy,
time_t timestamp) {
+#if !defined(EWK_BRINGUP)
DCHECK(location_manager_);
DCHECK(task_runner_);
base::BindOnce(&LocationProviderEfl::NotifyCallback,
base::Unretained(this), last_position_);
task_runner_->PostTask(FROM_HERE, std::move(task));
+#endif
}
void LocationProviderEfl::StartProvider(bool high_accuracy) {
location_manager_ = nullptr;
}
-const mojom::Geoposition& LocationProviderEfl::GetPosition() {
+const mojom::GeopositionResult* LocationProviderEfl::GetPosition() {
return last_position_;
}
#include "base/compiler_specific.h"
#include "base/memory/ptr_util.h"
+#include "base/task/single_thread_task_runner.h"
#include "services/device/geolocation/geolocation_provider.h"
#include "services/device/public/cpp/geolocation/geoposition.h"
#include "services/device/public/cpp/geolocation/location_provider.h"
const LocationProviderUpdateCallback& callback) override;
void StartProvider(bool high_accuracy) override;
void StopProvider() override;
- const mojom::Geoposition& GetPosition() override;
+ const mojom::GeopositionResult* GetPosition() override;
void OnPermissionGranted() override;
NotifyPositionChanged(double, double, double, double, double, double, time_t);
void NotifyCallback(const mojom::Geoposition&);
- mojom::Geoposition last_position_;
+ mojom::GeopositionResult* last_position_;
location_manager_h location_manager_;
+#if !defined(EWK_BRINGUP)
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+#endif
LocationProviderUpdateCallback callback_;
};
#if BUILDFLAG(IS_TIZEN)
#include <vconf.h>
-
+#if BUILDFLAG(IS_TIZEN_TV)
#include "components/xwalk_extensions/browser/xwalk_extension_manager.h"
#endif
+#endif
#include "private/ewk_notification_private.h"
switches::kXWalkExtensionPath)) {
return;
}
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
registry->AddInterface(
base::BindRepeating(&wrt::XWalkExtensionManager::Bind),
content::GetUIThreadTaskRunner({}));
#include "renderer/content_renderer_client_efl.h"
#include "ui/base/resource/resource_bundle.h"
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && BUILDFLAG(IS_TIZEN_TV)
#include "components/xwalk_extensions/browser/xwalk_extension_manager.h"
#endif
// needed for gpu thread
content::RegisterGpuMainThreadFactory(CreateInProcessGpuThread);
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
// switches::kXWalkExtensionPath SHOULD be set before MainDelegate init.
auto extension_path =
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
}
void EWebView::DeactivateAtk(bool deactivated) {
+#if defined(TIZEN_ATK_SUPPORT)
EWebAccessibilityUtil::GetInstance()->Deactivate(deactivated);
+#endif
}
void EWebView::ClearLabels() {
}
void EWebView::InitAtk() {
+#if defined(TIZEN_ATK_SUPPORT)
EWebAccessibilityUtil::GetInstance()->ToggleAtk(lazy_initialize_atk_);
+#endif
}
/* LCOV_EXCL_START */
#if BUILDFLAG(IS_TIZEN)
#include <vconf/vconf.h>
-
+#if BUILDFLAG(IS_TIZEN_TV)
#include "components/xwalk_extensions/renderer/xwalk_extension_renderer_controller.h"
#endif
+#endif
#include "base/command_line.h"
#include "base/path_service.h"
if (!command_line.HasSwitch(switches::kSingleProcess))
LocaleEfl::Initialize();
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
if (command_line.HasSwitch(switches::kXWalkExtensionPath)) {
wrt::XWalkExtensionRendererController::GetInstance().SetPrivilegeChecker(
base::BindRepeating([]() -> bool {
content::RenderFrame* render_frame,
v8::Handle<v8::Context> context,
int world_id) {
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
if (ShouldRegisterXWalkExtension(world_id))
wrt::XWalkExtensionRendererController::DidCreateScriptContext(context);
#endif
blink::WebFrame* frame,
v8::Handle<v8::Context> context,
int world_id) {
-#if BUILDFLAG(IS_TIZEN)
+#if BUILDFLAG(IS_TIZEN) && !defined(EWK_BRINGUP)
if (ShouldRegisterXWalkExtension(world_id))
wrt::XWalkExtensionRendererController::WillReleaseScriptContext(context);
#endif
break;
case SchemeVariant::kVibrant: {
const auto hues =
- std::to_array<double>({0, 41, 61, 101, 131, 181, 251, 301, 360});
+ std::array<double, 9>({0, 41, 61, 101, 131, 181, 251, 301, 360});
const auto secondary_rotations =
- std::to_array<double>({18, 15, 10, 12, 15, 18, 15, 12, 12});
+ std::array<double, 9>({18, 15, 10, 12, 15, 18, 15, 12, 12});
const base::flat_map<double, double> secondary_hues_to_rotations =
Zip(hues, secondary_rotations);
const auto tertiary_rotations =
- std::to_array<double>({35, 30, 20, 25, 30, 35, 30, 25, 25});
+ std::array<double, 9>({35, 30, 20, 25, 30, 35, 30, 25, 25});
const base::flat_map<double, double> tertiary_hues_to_rotations =
Zip(hues, tertiary_rotations);
break;
case SchemeVariant::kExpressive: {
const auto hues =
- std::to_array<double>({0, 21, 51, 121, 151, 191, 271, 321, 360});
+ std::array<double, 9>({0, 21, 51, 121, 151, 191, 271, 321, 360});
const auto secondary_rotations =
- std::to_array<double>({45, 95, 45, 20, 45, 90, 45, 45, 45});
+ std::array<double, 9>({45, 95, 45, 20, 45, 90, 45, 45, 45});
const base::flat_map<double, double> secondary_hues_to_rotations =
Zip(hues, secondary_rotations);
const auto tertiary_rotations =
- std::to_array<double>({120, 120, 20, 45, 20, 15, 20, 120, 120});
+ std::array<double, 9>({120, 120, 20, 45, 20, 15, 20, 120, 120});
const base::flat_map<double, double> tertiary_hues_to_rotations =
Zip(hues, tertiary_rotations);
config = {Transform(120.0, 40.0),
#if BUILDFLAG(IS_TIZEN)
#include "third_party/angle/src/gpu_info_util/SystemInfo.h"
-#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#include "third_party/swiftshader/include/vulkan/vulkan_core.h"
#elif BUILDFLAG(IS_LINUX)
#include <vulkan/vulkan_core.h>
#include "third_party/angle/src/gpu_info_util/SystemInfo.h" // nogncheck
# Lite mode disables a number of performance optimizations to reduce memory
# at the cost of performance.
# Sets -DV8_LITE_MODE.
- v8_enable_lite_mode = false
+ # FIXME(bringup m114): need to disable for tizen after resolving linker error
+ v8_enable_lite_mode = true
# Enable the Turbofan compiler.
# Sets -dV8_ENABLE_TURBOFAN.
JSHeapBroker* const prev_broker_;
};
#else
-class V8_NODISCARD V8_EXPORT_PRIVATE CurrentHeapBrokerScope {
+class V8_EXPORT_PRIVATE CurrentHeapBrokerScope {
public:
explicit CurrentHeapBrokerScope(JSHeapBroker* broker) {}
~CurrentHeapBrokerScope() {}
projects / platform / framework / web / chromium-efl.git / commitdiff