]
}
- if (is_linux || is_chromeos || is_android || is_fuchsia) {
+ if (is_linux || is_chromeos || is_android || is_fuchsia || is_tizen) {
sources += [
"files/file_path_watcher_inotify.cc",
"files/file_path_watcher_inotify.h",
#endif // defined(__clang_analyzer__)
// Use nomerge attribute to disable optimization of merging multiple same calls.
-#if defined(__clang__) && PA_HAS_ATTRIBUTE(nomerge)
+// FIXME: Enable for tizen if clang supports nomerge attribute
+#if defined(__clang__) && PA_HAS_ATTRIBUTE(nomerge) && !defined(OS_TIZEN)
#define PA_NOMERGE [[clang::nomerge]]
#else
#define PA_NOMERGE
#endif // defined(__clang_analyzer__)
// Use nomerge attribute to disable optimization of merging multiple same calls.
-#if defined(__clang__) && HAS_ATTRIBUTE(nomerge)
+#if defined(__clang__) && HAS_ATTRIBUTE(nomerge) && !defined(OS_TIZEN)
#define NOMERGE [[clang::nomerge]]
#else
#define NOMERGE
bool UncheckedMalloc(size_t size, void** result) {
#if BUILDFLAG(USE_ALLOCATOR_SHIM)
*result = allocator_shim::UncheckedAlloc(size);
-#elif defined(MEMORY_TOOL_REPLACES_ALLOCATOR) || !defined(LIBC_GLIBC)
+#elif defined(MEMORY_TOOL_REPLACES_ALLOCATOR) || !defined(LIBC_GLIBC) || \
+ defined(OS_TIZEN)
*result = malloc(size);
#elif defined(LIBC_GLIBC)
*result = __libc_malloc(size);
void UncheckedFree(void* ptr) {
#if BUILDFLAG(USE_ALLOCATOR_SHIM)
allocator_shim::UncheckedFree(ptr);
-#elif defined(MEMORY_TOOL_REPLACES_ALLOCATOR) || !defined(LIBC_GLIBC)
+#elif defined(MEMORY_TOOL_REPLACES_ALLOCATOR) || !defined(LIBC_GLIBC) || \
+ defined(OS_TIZEN)
free(ptr);
#elif defined(LIBC_GLIBC)
__libc_free(ptr);
#endif
// On iOS/EFL attach to the native loop when there is one.
-#if BUILDFLAG(IS_IOS) || defined(USE_EFL)
+#if BUILDFLAG(IS_IOS)
if (settings_.message_loop_type == MessagePumpType::UI) {
controller_->AttachToMessagePump();
}
// Returns true if the current run loop should quit when idle.
virtual bool ShouldQuitRunLoopWhenIdle() = 0;
-#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID) || defined(USE_EFL)
+#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID)
// On iOS, the main message loop cannot be Run(). Instead call
// AttachToMessagePump(), which connects this ThreadController to the
// UI thread's CFRunLoop and allows PostTask() to work.
return nullptr;
}
-#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID) || defined(USE_EFL)
+#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID)
void ThreadControllerImpl::AttachToMessagePump() {
NOTREACHED();
}
void SetTaskExecutionAllowed(bool allowed) override;
bool IsTaskExecutionAllowed() const override;
MessagePump* GetBoundMessagePump() const override;
-#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID) || defined(USE_EFL)
+#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID)
void AttachToMessagePump() override;
#endif
#if BUILDFLAG(IS_IOS)
#include "base/message_loop/message_pump_mac.h"
#elif BUILDFLAG(IS_ANDROID)
#include "base/message_loop/message_pump_android.h"
-#elif defined(USE_EFL)
-#include "base/message_loop/message_pump_for_ui_efl.h"
#endif
namespace base {
void ThreadControllerWithMessagePumpImpl::AttachToMessagePump() {
static_cast<MessagePumpForUI*>(pump_.get())->Attach(this);
}
-#elif defined(USE_EFL)
-void ThreadControllerWithMessagePumpImpl::AttachToMessagePump() {
- static_cast<MessagePumpForUIEfl*>(pump_.get())->Attach(this);
-}
#endif
base::TimeDelta ThreadControllerWithMessagePumpImpl::GetAlternationInterval() {
MessagePump* GetBoundMessagePump() const override;
void PrioritizeYieldingToNative(base::TimeTicks prioritize_until) override;
void EnablePeriodicYieldingToNative(base::TimeDelta delta) override;
-#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID) || defined(USE_EFL)
+#if BUILDFLAG(IS_IOS) || BUILDFLAG(IS_ANDROID)
void AttachToMessagePump() override;
#endif
#if BUILDFLAG(IS_IOS)
"pthread",
"rt",
]
+
+ if (is_tizen && is_clang) {
+ libs += [ "atomic" ]
+ }
}
}
ozone_platform = "x11"
ozone_platform_drm = true
ozone_platform_x11 = true
- } else if (is_chromeos_lacros) {
+ } else if (is_chromeos_lacros || is_tizen) {
ozone_platform = "wayland"
ozone_platform_wayland = true
} else if (is_linux) {
# //chrome/installer/util/BUILD.gn.
assert_no_deps = [ "//chrome/installer/util:strings" ]
}
-if (!is_android && !is_mac && !is_tizen) {
+if (!is_android && !is_mac) {
group("chrome") {
public_deps = [ ":chrome_initial" ]
data_deps = [ ":chrome_initial" ]
# found in the LICENSE file.
import("//build/config/ui.gni")
-assert(is_chromeos || is_linux || is_mac || is_win || is_fuchsia,
+assert(is_chromeos || is_linux || is_mac || is_win || is_fuchsia || is_tizen,
"Image Editor is for desktop plaforms only")
static_library("image_editor_component_util") {
import("//tools/typescript/ts_library.gni")
import("//ui/webui/resources/tools/generate_grd.gni")
-assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia)
+assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia || is_tizen)
grit("resources") {
defines = chrome_grit_defines + [ "is_official_build=$is_official_build" ]
import("//ui/webui/resources/tools/generate_grd.gni")
import("//ui/webui/webui_features.gni")
-assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia)
+assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia || is_tizen)
import("//chrome/browser/resources/tools/build_webui.gni")
import("//mojo/public/tools/bindings/mojom.gni")
-assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia)
+assert(is_linux || is_chromeos || is_win || is_mac || is_fuchsia || is_tizen)
mojom("mojo_bindings") {
sources = [ "tab_search.mojom" ]
}
}
-if (is_fuchsia) {
+if (is_fuchsia || is_tizen) {
# TODO(crbug.com/1310086): Split performance_web_engine_test_suite
# into fuchsia-chrome and web_engine test, and put fuchsia-chrome
# test target here.
"//components/heap_profiling/in_process",
"//components/safe_browsing:buildflags",
]
- if (!is_fuchsia) {
+ if (!is_fuchsia || is_tizen) {
deps += [ "//third_party/breakpad:client" ]
}
if (enable_gwp_asan) {
"//third_party/crashpad/crashpad/client",
]
}
-
- if (is_tizen) {
- deps -= [ "//third_party/breakpad:client" ]
- }
}
source_set("unit_tests") {
"crashpad.h",
]
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [ "crashpad_linux.cc" ]
}
# enable these flags (but don't check that in!).
gen_policy_templates_common = true
gen_policy_templates_win = is_win
-gen_policy_templates_linux = is_linux || is_chromeos
+gen_policy_templates_linux = is_linux || is_chromeos || is_tizen
gen_policy_templates_android = is_android
gen_policy_templates_mac = is_mac
gen_policy_templates_chromeos = is_chromeos_ash
policy for policy in policies
if (policy.is_supported or is_deprecated(policy))
]
-
- return [policy for policy in policies if policy.is_supported]
+# FIMXE(Bringup:M108): for TIZEN some policies are not generated hence add back policy.is_supported
+ return [policy for policy in policies]
#------------------ policy constants header ------------------------#
public_deps = [ "//skia" ]
- if (enable_pdf && (is_linux || is_chromeos)) {
+ if (enable_pdf && (is_linux || is_chromeos || is_tizen)) {
sources += [
"pdf_fontconfig_matching.cc",
"pdf_fontconfig_matching.h",
import("//build/config/chromeos/ui_mode.gni")
# Dice is supported on the platform (but not necessarily enabled).
-enable_dice_support = is_linux || is_mac || is_win || is_fuchsia
+enable_dice_support = is_linux || is_mac || is_win || is_fuchsia || is_tizen
# Mirror is enabled and other account consistency mechanisms are not available.
enable_mirror = is_android || is_chromeos || is_ios
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "gpu/command_buffer/service/single_task_sequence.h"
#include "gpu/command_buffer/service/skia_utils.h"
+#include "gpu/command_buffer/service/sync_point_manager.h"
#include "gpu/ipc/service/context_url.h"
#include "gpu/vulkan/buildflags.h"
#include "skia/buildflags.h"
#include "skia/ext/legacy_display_globals.h"
+#include "third_party/skia/include/core/SkPromiseImageTexture.h"
#include "third_party/skia/include/gpu/GrYUVABackendTextures.h"
#include "ui/base/ui_base_features.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include <utility>
#include <vector>
-#include "base/atomic_sequence_num.h"
#include "base/debug/crash_logging.h"
#include "base/functional/bind.h"
#include "base/functional/callback.h"
-#include "base/memory/raw_ptr.h"
#include "base/memory/scoped_refptr.h"
#include "base/notreached.h"
#include "base/task/bind_post_task.h"
#include "base/threading/thread_checker.h"
-#include "base/threading/thread_task_runner_handle.h"
-#include "base/trace_event/memory_dump_manager.h"
-#include "base/trace_event/trace_event.h"
#include "build/build_config.h"
#include "components/viz/common/features.h"
#include "components/viz/common/frame_sinks/blit_request.h"
#include "components/viz/common/skia_helper.h"
#include "components/viz/common/viz_utils.h"
#include "components/viz/service/display/output_surface_frame.h"
-#include "components/viz/service/display/overlay_candidate.h"
#include "components/viz/service/display_embedder/image_context_impl.h"
#include "components/viz/service/display_embedder/output_presenter_gl.h"
#include "components/viz/service/display_embedder/skia_output_device.h"
#include "gpu/command_buffer/common/mailbox_holder.h"
#include "gpu/command_buffer/common/swap_buffers_complete_params.h"
#include "gpu/command_buffer/common/sync_token.h"
-#include "gpu/command_buffer/service/external_semaphore.h"
+#include "gpu/command_buffer/service/display_compositor_memory_and_task_controller_on_gpu.h"
#include "gpu/command_buffer/service/gr_shader_cache.h"
#include "gpu/command_buffer/service/memory_tracking.h"
#include "gpu/command_buffer/service/scheduler.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "gpu/command_buffer/service/skia_utils.h"
+#include "gpu/command_buffer/service/sync_point_manager.h"
#include "gpu/config/gpu_preferences.h"
#include "gpu/ipc/common/gpu_client_ids.h"
#include "gpu/ipc/common/gpu_peak_memory.h"
#include "third_party/skia/include/core/SkDeferredDisplayList.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkPixelRef.h"
+#include "third_party/skia/include/core/SkPromiseImageTexture.h"
#include "third_party/skia/include/core/SkSamplingOptions.h"
#include "third_party/skia/include/core/SkSize.h"
#include "third_party/skia/include/core/SkYUVAInfo.h"
#include "ui/gfx/gpu_fence_handle.h"
#include "ui/gl/gl_fence.h"
#include "ui/gl/gl_surface.h"
+#include "url/gurl.h"
#if BUILDFLAG(IS_WIN)
#include "components/viz/service/display/dc_layer_overlay.h"
#include "base/containers/circular_deque.h"
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
-#include "base/containers/span.h"
#include "base/memory/raw_ptr.h"
+#include "base/memory/scoped_refptr.h"
#include "base/threading/thread_checker.h"
-#include "base/types/id_type.h"
#include "base/types/pass_key.h"
#include "build/build_config.h"
#include "components/viz/common/display/renderer_settings.h"
#include "components/viz/common/gpu/context_lost_reason.h"
-#include "components/viz/common/quads/compositor_render_pass.h"
#include "components/viz/common/resources/release_callback.h"
#include "components/viz/service/display/external_use_client.h"
#include "components/viz/service/display/output_surface.h"
#include "gpu/command_buffer/common/sync_token.h"
#include "gpu/command_buffer/service/shared_context_state.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
-#include "gpu/command_buffer/service/sync_point_manager.h"
-#include "gpu/ipc/service/context_url.h"
#include "gpu/ipc/service/image_transport_surface_delegate.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#include "third_party/skia/include/core/SkDeferredDisplayList.h"
-#include "third_party/skia/include/core/SkPromiseImageTexture.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "third_party/skia/include/gpu/GrBackendSemaphore.h"
#include "third_party/skia/include/gpu/GrTypes.h"
}
namespace gpu {
+class DisplayCompositorMemoryAndTaskControllerOnGpu;
class SharedImageRepresentationFactory;
class SharedImageFactory;
class SyncPointClientState;
class AsyncReadResultLock;
class DawnContextProvider;
class ImageContextImpl;
+class SkiaOutputSurfaceDependency;
class VulkanContextProvider;
namespace copy_output {
"//ppapi/shared_impl",
]
- assert(enable_basic_printing)
- deps += [ "//printing" ]
+ if (enable_basic_printing) {
+ deps += [ "//printing" ]
+ }
if (is_chromeos) {
sources += [
]
}
-if (is_linux || is_chromeos) {
+if (is_linux || is_chromeos || is_tizen) {
source_set("sandbox_support_linux") {
public = [
"zygote/zygote_commands_linux.h",
sources -= [ "cursors/webcursor_aura.cc" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
deps += [
":sandbox_support_linux",
":set_process_title_linux",
deps = [ "//base:base" ]
}
-if (is_linux || is_chromeos) {
+if (is_linux || is_chromeos || is_tizen) {
source_set("set_process_title_linux") {
public = [ "set_process_title_linux.h" ]
sources = [ "set_process_title_linux.cc" ]
if (enable_ipc_logging) {
enabled_features += [ "ipc_logging" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "supports_thread_types" ]
}
if (use_clang_profiling_inside_sandbox) {
// Reinitialize logging. Needed on ChromeOS, which switches to a log file
// in the user's home directory once they log in.
kZygoteCommandReinitializeLogging = 5
+#if defined(OS_TIZEN)
+ // Load injected bundle library.
+ ,
+ kZygoteCommandLoadInjectedBundle = 6,
+
+ // Drop privilege of zygote process.
+ kZygoteCommandDropProcessPrivileges = 7,
+#endif
};
} // namespace content
# This target allows other targets to depend on sandbox_support_linux.h which is
# a header-only dependency, without bringing in all of content.
-if (is_linux || is_chromeos) {
+if (is_linux || is_chromeos || is_tizen) {
source_set("sandbox_support_linux") {
public = [
"//content/common/content_export.h",
deps += [ "//gin" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
deps += [ "//ui/linux:linux_ui_factory" ]
}
switches::kCrashDumpsDir,
switches::kEnableCrashReporter,
switches::kExposeInternalsForTesting,
+#if !defined(OS_TIZEN)
switches::kRunWebTests,
+#endif
};
command_line->CopySwitchesFrom(*base::CommandLine::ForCurrentProcess(),
]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"sandbox_status_service.cc",
"sandbox_status_service.h",
mojom("test_interfaces") {
testonly = true
sources = [ "echo.test-mojom" ]
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [ "sandbox_status.test-mojom" ]
}
}
}
}
- if (is_linux || is_chromeos_ash) {
+ if (is_linux || is_chromeos_ash || is_tizen) {
deps += [
"//gpu/config",
"//media/gpu/sandbox",
// interference. This GPU process is launched 120 seconds after chrome starts.
command_line.AppendSwitch(switches::kDisableGpuProcessForDX12InfoCollection);
-#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC) || BUILDFLAG(IS_LINUX) || \
- BUILDFLAG(IS_CHROMEOS)
+#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC) || \
+ (BUILDFLAG(IS_LINUX) && !defined(OS_TIZEN)) || BUILDFLAG(IS_CHROMEOS)
content::WebTestBrowserPlatformInitialize();
#endif
"//ui/base",
]
- if (is_tizen) {
- sources += [ "bluetooth_adapter_stub.cc" ]
- }
-
public_deps = [ "//device/bluetooth/public/cpp" ]
if (is_android) {
]
}
- if (is_chromeos || is_linux) {
+ if (is_chromeos || is_linux || is_tizen) {
if (use_bluez) {
if (!force_cast_bluetooth) {
sources += [ "bluetooth_adapter_chromeos.cc" ]
use_real_dbus_clients = false
}
- if (is_tizen) {
- sources += [
- "dbus/dbus_bluez_manager_wrapper_linux.cc",
- "dbus/dbus_bluez_manager_wrapper_linux.h",
- "dbus/dbus_thread_manager_linux.cc",
- "dbus/dbus_thread_manager_linux.h",
- ]
- }
-
if (!use_real_dbus_clients) {
# Use fake D-Bus clients instead of real ones.
sources += [
declare_args() {
force_cast_bluetooth = false
- use_bluez = (is_linux && !is_castos && use_dbus) || is_chromeos
+ use_bluez = ((is_linux || is_tizen) && !is_castos && use_dbus) || is_chromeos
}
}
if (use_ozone) {
+ sources += [
+ "shared_image/gl_ozone_image_representation.cc",
+ "shared_image/gl_ozone_image_representation.h",
+ "shared_image/ozone_image_backing.cc",
+ "shared_image/ozone_image_backing.h",
+ "shared_image/ozone_image_backing_factory.cc",
+ "shared_image/ozone_image_backing_factory.h",
+ ]
deps += [
"//ui/base:features",
"//ui/ozone",
if (use_ozone) {
sources += [
- "shared_image/gl_ozone_image_representation.cc",
- "shared_image/gl_ozone_image_representation.h",
- "shared_image/ozone_image_backing.cc",
- "shared_image/ozone_image_backing.h",
- "shared_image/ozone_image_backing_factory.cc",
- "shared_image/ozone_image_backing_factory.h",
"shared_image/skia_vk_ozone_image_representation.cc",
"shared_image/skia_vk_ozone_image_representation.h",
]
"shared_image/external_vk_image_dawn_representation.h",
]
}
-
- if (use_ozone && use_dawn) {
- sources += [
- "shared_image/dawn_ozone_image_representation.cc",
- "shared_image/dawn_ozone_image_representation.h",
- ]
- }
}
if (use_dawn) {
"shared_image/dawn_egl_image_representation.h",
]
}
+
+ if (use_ozone) {
+ sources += [
+ "shared_image/dawn_ozone_image_representation.cc",
+ "shared_image/dawn_ozone_image_representation.h",
+ ]
+ }
}
if (is_mac) {
#ifndef GPU_COMMAND_BUFFER_SERVICE_EXTERNAL_SEMAPHORE_H_
#define GPU_COMMAND_BUFFER_SERVICE_EXTERNAL_SEMAPHORE_H_
+#if defined(OS_TIZEN)
+#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#else
#include <vulkan/vulkan_core.h>
+#endif
#include "base/memory/raw_ptr.h"
#include "base/types/pass_key.h"
#include "gpu/command_buffer/service/shared_image/shared_image_manager.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "gpu/command_buffer/service/shared_image/skia_gl_image_representation.h"
-#include "gpu/command_buffer/service/shared_image/skia_vk_ozone_image_representation.h"
#include "gpu/command_buffer/service/shared_memory_region_wrapper.h"
#include "gpu/command_buffer/service/skia_utils.h"
-#include "gpu/vulkan/vulkan_image.h"
-#include "gpu/vulkan/vulkan_implementation.h"
#include "third_party/skia/include/core/SkPromiseImageTexture.h"
#include "third_party/skia/include/gpu/GrBackendSemaphore.h"
#include "ui/gfx/buffer_format_util.h"
#include "ui/gl/buildflags.h"
#include "ui/gl/gl_image_native_pixmap.h"
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "gpu/command_buffer/service/shared_image/skia_vk_ozone_image_representation.h"
+#include "gpu/vulkan/vulkan_image.h"
+#include "gpu/vulkan/vulkan_implementation.h"
+#endif // BUILDFLAG(ENABLE_VULKAN)
+
#if BUILDFLAG(USE_DAWN)
#include "gpu/command_buffer/service/shared_image/dawn_ozone_image_representation.h"
#endif // BUILDFLAG(USE_DAWN)
return skia_representation;
}
if (context_state->GrContextIsVulkan()) {
+#if BUILDFLAG(ENABLE_VULKAN)
auto* device_queue = context_state->vk_context_provider()->GetDeviceQueue();
gfx::GpuMemoryBufferHandle gmb_handle;
gmb_handle.type = gfx::GpuMemoryBufferType::NATIVE_PIXMAP;
return std::make_unique<SkiaVkOzoneImageRepresentation>(
manager, this, std::move(context_state), std::move(vulkan_image),
tracker);
+#else
+ NOTREACHED() << "Vulkan is disabled.";
+ return nullptr;
+#endif // BUILDFLAG(ENABLE_VULKAN)
}
NOTIMPLEMENTED_LOG_ONCE();
return nullptr;
#include "build/build_config.h"
#include "build/chromecast_buildflags.h"
#include "build/chromeos_buildflags.h"
-#include "components/viz/common/gpu/vulkan_context_provider.h"
#include "components/viz/common/resources/resource_format_utils.h"
#include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/command_buffer/service/service_utils.h"
#include "gpu/command_buffer/service/shared_image/ozone_image_backing.h"
#include "gpu/command_buffer/service/shared_memory_region_wrapper.h"
-#include "gpu/vulkan/vulkan_device_queue.h"
#include "ui/gfx/gpu_memory_buffer.h"
#include "ui/gfx/native_pixmap.h"
#include "ui/gl/buildflags.h"
#include "ui/ozone/public/ozone_platform.h"
#include "ui/ozone/public/surface_factory_ozone.h"
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "components/viz/common/gpu/vulkan_context_provider.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
+#endif // BUILDFLAG(ENABLE_VULKAN)
+
namespace gpu {
namespace {
SkAlphaType alpha_type,
uint32_t usage) {
gfx::BufferFormat buffer_format = viz::BufferFormat(format);
- VkDevice vk_device = VK_NULL_HANDLE;
+ VulkanDeviceQueue* device_queue = nullptr;
DCHECK(shared_context_state_);
+#if BUILDFLAG(ENABLE_VULKAN)
if (shared_context_state_->vk_context_provider()) {
- vk_device = shared_context_state_->vk_context_provider()
- ->GetDeviceQueue()
- ->GetVulkanDevice();
+ device_queue =
+ shared_context_state_->vk_context_provider()->GetDeviceQueue();
}
+#endif // BUILDFLAG(ENABLE_VULKAN)
ui::SurfaceFactoryOzone* surface_factory =
ui::OzonePlatform::GetInstance()->GetSurfaceFactoryOzone();
scoped_refptr<gfx::NativePixmap> pixmap = surface_factory->CreateNativePixmap(
- surface_handle, vk_device, size, buffer_format, GetBufferUsage(usage));
+ surface_handle, device_queue, size, buffer_format, GetBufferUsage(usage));
// Fallback to GPU_READ if cannot create pixmap with SCANOUT
if (!pixmap) {
- pixmap = surface_factory->CreateNativePixmap(surface_handle, vk_device,
+ pixmap = surface_factory->CreateNativePixmap(surface_handle, device_queue,
size, buffer_format,
gfx::BufferUsage::GPU_READ);
}
}
bool OzoneImageBackingFactory::CanImportNativePixmapToVulkan() {
+#if BUILDFLAG(ENABLE_VULKAN)
if (!shared_context_state_->vk_context_provider()) {
return false;
}
return shared_context_state_->vk_context_provider()
->GetVulkanImplementation()
->CanImportGpuMemoryBuffer(vk_device, gfx::NATIVE_PIXMAP);
+#else
+ return false;
+#endif // BUILDFLAG(ENABLE_VULKAN)
}
bool OzoneImageBackingFactory::CanImportNativePixmapToWebGPU() {
#include "ui/ozone/public/surface_factory_ozone.h"
#endif
-#if BUILDFLAG(IS_ANDROID) && BUILDFLAG(ENABLE_VULKAN)
-#include "gpu/command_buffer/service/shared_image/ahardwarebuffer_image_backing_factory.h"
-#elif BUILDFLAG(IS_MAC)
+#if BUILDFLAG(IS_MAC)
#include "gpu/command_buffer/service/shared_image/iosurface_image_backing_factory.h"
#endif
#if BUILDFLAG(IS_ANDROID)
#include "base/android/android_hardware_buffer_compat.h"
+#include "gpu/command_buffer/service/shared_image/ahardwarebuffer_image_backing_factory.h"
#include "gpu/command_buffer/service/shared_image/egl_image_backing_factory.h"
#endif
gpu_preferences, workarounds, context_state);
factories_.push_back(std::move(factory));
}
-#endif
-#if BUILDFLAG(IS_WIN) && BUILDFLAG(ENABLE_VULKAN)
+#if BUILDFLAG(IS_WIN)
if (gr_context_type_ == GrContextType::kVulkan) {
auto external_vk_image_factory =
std::make_unique<ExternalVkImageBackingFactory>(context_state);
factories_.push_back(std::move(external_vk_image_factory));
}
-#elif BUILDFLAG(IS_ANDROID)
+#endif // BUILDFLAG(IS_WIN)
+#endif // BUILDFLAG(ENABLE_VULKAN)
+#if BUILDFLAG(IS_ANDROID)
if (use_gl) {
auto egl_backing_factory = std::make_unique<EGLImageBackingFactory>(
gpu_preferences, workarounds, feature_info.get());
feature_info.get());
factories_.push_back(std::move(ahb_factory));
}
-#if BUILDFLAG(ENABLE_VULKAN)
if (gr_context_type_ == GrContextType::kVulkan &&
!base::FeatureList::IsEnabled(features::kVulkanFromANGLE)) {
auto external_vk_image_factory =
std::make_unique<ExternalVkImageBackingFactory>(context_state);
factories_.push_back(std::move(external_vk_image_factory));
}
-#endif // BUILDFLAG(ENABLE_VULKAN)
#elif defined(USE_OZONE)
// For all Ozone platforms - Desktop Linux, ChromeOS, Fuchsia, CastOS.
if (ui::OzonePlatform::GetInstance()
scoped_refptr<gfx::NativePixmap> pixmap;
pixmap = ui::OzonePlatform::GetInstance()
->GetSurfaceFactoryOzone()
- ->CreateNativePixmap(gfx::kNullAcceleratedWidget, VK_NULL_HANDLE,
- size, format, usage);
+ ->CreateNativePixmap(gfx::kNullAcceleratedWidget, nullptr, size,
+ format, usage);
if (!pixmap) {
// TODO(j.isorce): use gbm_bo_create / gbm_bo_get_fd from system libgbm.
NOTIMPLEMENTED();
#include "build/build_config.h"
#include "components/viz/common/gpu/vulkan_context_provider.h"
#include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
-#include "gpu/vulkan/vulkan_device_queue.h"
#include "ui/gfx/buffer_format_util.h"
#include "ui/gfx/buffer_usage_util.h"
#include "ui/gfx/client_native_pixmap.h"
#include "ui/gl/gl_image_glx_native_pixmap.h" // nogncheck
#endif
+#if BUILDFLAG(ENABLE_VULKAN)
+#include "gpu/vulkan/vulkan_device_queue.h"
+#endif
+
namespace gpu {
namespace {
scoped_refptr<gfx::NativePixmap> pixmap =
ui::OzonePlatform::GetInstance()
->GetSurfaceFactoryOzone()
- ->CreateNativePixmap(surface_handle, GetVulkanDevice(), size, format,
- usage, framebuffer_size);
+ ->CreateNativePixmap(surface_handle, GetVulkanDeviceQueue(), size,
+ format, usage, framebuffer_size);
return CreateGpuMemoryBufferFromNativePixmap(id, size, format, usage,
client_id, std::move(pixmap));
}
ui::OzonePlatform::GetInstance()
->GetSurfaceFactoryOzone()
->CreateNativePixmapAsync(
- surface_handle, GetVulkanDevice(), size, format, usage,
+ surface_handle, GetVulkanDeviceQueue(), size, format, usage,
base::BindOnce(
&GpuMemoryBufferFactoryNativePixmap::OnNativePixmapCreated, id,
size, format, usage, client_id, std::move(callback),
scoped_refptr<gfx::NativePixmap> pixmap;
pixmap = ui::OzonePlatform::GetInstance()
->GetSurfaceFactoryOzone()
- ->CreateNativePixmap(surface_handle, GetVulkanDevice(), size,
- format, usage);
+ ->CreateNativePixmap(surface_handle, GetVulkanDeviceQueue(),
+ size, format, usage);
if (!pixmap.get()) {
LOG(ERROR) << "Failed to create pixmap " << size.ToString() << ", "
<< gfx::BufferFormatToString(format) << ", usage "
return GL_TEXTURE_2D;
}
-VkDevice GpuMemoryBufferFactoryNativePixmap::GetVulkanDevice() {
- return vulkan_context_provider_
- ? vulkan_context_provider_->GetDeviceQueue()->GetVulkanDevice()
- : VK_NULL_HANDLE;
+VulkanDeviceQueue* GpuMemoryBufferFactoryNativePixmap::GetVulkanDeviceQueue() {
+#if BUILDFLAG(ENABLE_VULKAN)
+ if (vulkan_context_provider_)
+ return vulkan_context_provider_->GetDeviceQueue();
+#endif
+
+ return nullptr;
}
// static
#ifndef GPU_IPC_SERVICE_GPU_MEMORY_BUFFER_FACTORY_NATIVE_PIXMAP_H_
#define GPU_IPC_SERVICE_GPU_MEMORY_BUFFER_FACTORY_NATIVE_PIXMAP_H_
+#if defined(OS_TIZEN)
+#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#else
#include <vulkan/vulkan_core.h>
+#endif
#include <unordered_map>
#include <utility>
namespace gpu {
+class VulkanDeviceQueue;
+
class GPU_IPC_SERVICE_EXPORT GpuMemoryBufferFactoryNativePixmap
: public GpuMemoryBufferFactory,
public ImageFactory {
int client_id,
scoped_refptr<gfx::NativePixmap> pixmap);
- VkDevice GetVulkanDevice();
+ VulkanDeviceQueue* GetVulkanDeviceQueue();
scoped_refptr<viz::VulkanContextProvider> vulkan_context_provider_;
#ifndef GPU_VULKAN_VMA_WRAPPER_H_
#define GPU_VULKAN_VMA_WRAPPER_H_
+#if defined(OS_TIZEN)
+#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#else
#include <vulkan/vulkan_core.h>
+#endif
#include "base/component_export.h"
#ifndef GPU_VULKAN_VULKAN_DEVICE_QUEUE_H_
#define GPU_VULKAN_VULKAN_DEVICE_QUEUE_H_
+#if defined(OS_TIZEN)
+#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan_core.h"
+#else
#include <vulkan/vulkan_core.h>
+#endif
#include <memory>
NaClHostMsgStart,
EncryptedMediaMsgStart,
GinJavaBridgeMsgStart,
+#if defined(OS_TIZEN)
+ TtsMsgStart,
+#endif
ExtensionWorkerMsgStart,
LastIPCMsgStart // Must come last.
};
]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"video/linux/scoped_v4l2_device_fd.cc",
"video/linux/scoped_v4l2_device_fd.h",
# Explicitly define what we use to avoid confusion.
if (is_chromeos) {
component_os = "cros"
-} else if (is_linux) {
+} else if (is_linux || is_tizen) {
component_os = "linux"
} else if (is_win) {
component_os = "win"
import("//build/config/chromeos/ui_mode.gni")
import("//media/gpu/args.gni")
-assert(is_linux || is_chromeos_ash)
+assert(is_linux || is_chromeos_ash || is_tizen)
source_set("sandbox") {
sources = [
sources = [ "native_pixmap_handle.mojom" ]
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
cpp_typemaps = [
{
types = [
Name: chromium-efl
Summary: Chromium EFL
# Set by by scripts/update-chromium-version.sh
-%define ChromiumVersion 94.0.4606.31
+%define ChromiumVersion 108.0.5359.1
%define Week 1
Version: %{ChromiumVersion}.%{Week}
Release: 1
Requires(postun): /sbin/ldconfig
BuildRequires: binutils-gold
-BuildRequires: bison, edje-tools, expat-devel, flex, gettext, gperf, libcap-devel
+BuildRequires: bison, edje-tools, expat-devel, flex, gettext, gperf, libcap-devel, libcurl, libatomic
BuildRequires: libjpeg-turbo-devel, ninja, perl, python3, python3-xml, which
BuildRequires: pkgconfig(capi-appfw-application)
BuildRequires: pkgconfig(capi-appfw-app-manager)
BuildRequires: pkgconfig(icu-i18n)
BuildRequires: pkgconfig(libdrm)
BuildRequires: pkgconfig(libevent)
+BuildRequires: pkgconfig(libcurl)
BuildRequires: pkgconfig(libexif)
BuildRequires: pkgconfig(libffi)
BuildRequires: pkgconfig(libpng)
%if 0%{?build_ewk_unittests}
ewk_unittests \
%endif
- efl_webprocess chromium-ewk efl_webview_app mini_browser ubrowser
+ efl_webprocess chromium-ewk efl_webview_app mini_browser ubrowser content_shell
%if 0%{?_enable_unittests}
ninja %{_smp_mflags} -C"%{OUTPUT_FOLDER}" angle_unittests env_chromium_unittests cacheinvalidation_unittests \
install -m 0644 tizen_src/ewk/efl_integration/public/*.h "%{buildroot}"%{_includedir}/chromium-ewk/
install -m 0644 v8/include/*.h "%{buildroot}"%{_includedir}/v8/
-%if 0%{?_enable_content_shell}
install -m 0755 "%{OUTPUT_FOLDER}"/content_shell "%{buildroot}%{CHROMIUM_EXE_DIR}"/content_shell
sed 's#@binary@#%{CHROMIUM_EXE_DIR}/content_shell#' %{SOURCE1} > "%{buildroot}"%{_bindir}/content_shell
-%endif
+
+install -m 0755 "%{OUTPUT_FOLDER}"/libminigbm.so "%{buildroot}"%{_libdir}
%if 0%{?_enable_unittests}
install -d "%{INSTALL_ROOT}%{CHROMIUM_UNITTESTS_DIR}"
%{_xmldir}/%{_pkgid}.xml
%defattr(-,root,root,-)
%{_libdir}/libchromium-ewk.so
+%{_libdir}/libminigbm.so
%if "%{?tizen_profile_name}" == "tv"
%caps(cap_mac_admin,cap_mac_override,cap_setgid=ei) %{CHROMIUM_EXE_DIR}/efl_webprocess
%else
%{CHROMIUM_EXE_DIR}/locales/*.pak
%{CHROMIUM_DATA_DIR}/themes/*.edj
%{CHROMIUM_LOCALE_DIR}
+%{CHROMIUM_EXE_DIR}/content_shell
+%{_bindir}/content_shell
%files devel
%defattr(-,root,root,-)
import("//build/config/features.gni")
import("//pdf/features.gni")
import("//ppapi/buildflags/buildflags.gni")
+import("//printing/buildflags/buildflags.gni")
import("//testing/libfuzzer/fuzzer_test.gni")
import("//testing/test.gni")
import("//third_party/pdfium/pdfium.gni")
"//components/strings",
"//gin",
"//pdf/loader",
- "//printing",
"//third_party/blink/public:blink_headers",
"//third_party/blink/public/common:headers",
"//third_party/icu",
"//ui/gfx/range",
]
+ if (enable_basic_printing) {
+ deps += [ "//printing" ]
+ }
+
if (is_linux || is_chromeos) {
sources += [
"pdfium/pdfium_font_linux.cc",
"//gin",
"//net",
"//pdf/loader",
- "//printing",
"//services/network/public/mojom:url_loader_base",
"//skia",
"//third_party/blink/public:blink_headers",
"//ui/gfx/range",
"//v8",
]
+
+ if (enable_basic_printing) {
+ deps += [ "//printing" ]
+ }
}
source_set("pdf_test_utils") {
"//net",
"//pdf/loader",
"//pdf/loader:unit_tests",
- "//printing",
"//skia",
"//testing/gmock",
"//testing/gtest",
"//v8",
]
+ if (enable_basic_printing) {
+ deps += [ "//printing" ]
+ }
+
if (v8_use_external_startup_data) {
deps += [ "//tools/v8_context_snapshot" ]
configs += [
if (enable_ppapi) {
enabled_features += [ "enable_ppapi" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "has_zygote" ]
}
- if (is_linux || is_chromeos_ash) {
+ if (is_linux || is_chromeos_ash || is_tizen) {
enabled_features += [ "is_linux_or_chromeos_ash" ]
}
if (enable_cros_libassistant) {
"//mojo/public/cpp/bindings",
]
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"core_times.cc",
"core_times.h",
deps += [ "//third_party/libusb" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"usb_device_linux.cc",
"usb_device_linux.h",
}
if (use_udev) {
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"usb_service_linux.cc",
"usb_service_linux.h",
os_dump->is_peak_rss_resettable = internal_os_dump.is_peak_rss_resettable;
os_dump->private_footprint_kb =
CalculatePrivateFootprintKb(internal_os_dump, shared_resident_kb);
-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
+#if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || \
+ BUILDFLAG(IS_ANDROID)) && \
+ !defined(OS_TIZEN)
os_dump->private_footprint_swap_kb =
internal_os_dump.platform_private_footprint->vm_swap_bytes / 1024;
#endif
DidCompleteSwapWithSize(gfx.mojom.Size size);
// Notifies that a swap has occurred with a new size.
- [EnableIf=is_linux]
DidCompleteSwapWithNewSize(gfx.mojom.Size size);
// Notifies the client of the result of context creation attempt. On Android we can't
declare_args() {
build_angle_gles1_conform_tests = false
build_angle_trace_perf_tests = false
- build_angle_perftests =
- is_win || is_linux || is_chromeos || is_android || is_apple || is_fuchsia
+ build_angle_perftests = is_win || is_linux || is_chromeos || is_android ||
+ is_apple || is_fuchsia || is_tizen
}
if (is_android) {
}
}
-if (is_win || is_linux || is_chromeos || is_android || is_fuchsia || is_apple) {
+if (is_win || is_linux || is_chromeos || is_android || is_fuchsia || is_apple ||
+ is_tizen) {
import("angle_end2end_tests.gni")
angle_test("angle_end2end_tests") {
":angle_unittests",
"capture_replay_tests",
]
- if (!is_fuchsia) {
+ if (!is_fuchsia && !is_tizen) {
deps += [
":angle_white_box_perftests",
":angle_white_box_tests",
}
// Hue is in the range of 0 to 6.0, the remainder are in the range 0 to 1.0
-constexpr RGBA32 MakeRGBAFromHSLA(double hue,
- double saturation,
- double lightness,
- double alpha) {
+// FIXME: round function doesnt evaluate to constexpr
+RGBA32 MakeRGBAFromHSLA(double hue,
+ double saturation,
+ double lightness,
+ double alpha) {
const double scale_factor = 255.0;
double r = 0, g = 0, b = 0;
HSLToRGB(hue, saturation, lightness, r, g, b);
return g * (1.0f / 400.0f);
}
+// FIXME: std::floor doesnt evalulate to constexpr hence added user defined
+// implementation
constexpr double RoundHalfTowardsPositiveInfinity(double value) {
+#if defined EWK_BRINGUP && !defined(OS_TIZEN)
return std::floor(value + 0.5);
+#else
+ double new_value = value + 0.5;
+ if (new_value < 0)
+ return (int)new_value - 1;
+ else
+ return (int)new_value;
+#endif
}
+// FIXME: Not used anywhere in code hence disabled only for tizen profile
+#if defined EWK_BRINGUP && !defined(OS_TIZEN)
constexpr float RoundHalfTowardsPositiveInfinity(float value) {
return std::floor(value + 0.5f);
}
+#endif
// ClampTo() is implemented by templated helper classes (to allow for partial
// template specialization) as well as several helper functions.
}
}
-if (is_linux || is_chromeos || is_android) {
+if (is_linux || is_chromeos || is_android || is_tizen) {
if (current_toolchain == host_toolchain) {
executable("symupload") {
sources = [
# This is the parent directory that contains the mini_chromium source dir.
# This variable is not used when crashpad_is_in_chromium.
if (crashpad_is_in_fuchsia) {
- mini_chromium_source_parent = "//third_party/crashpad/third_party/mini_chromium"
+ mini_chromium_source_parent =
+ "//third_party/crashpad/third_party/mini_chromium"
} else {
mini_chromium_source_parent = "../third_party/mini_chromium"
}
crashpad_is_mac = is_mac
crashpad_is_ios = is_ios
crashpad_is_win = is_win
- crashpad_is_linux = is_linux || is_chromeos
+ crashpad_is_linux = is_linux || is_chromeos || is_tizen
crashpad_is_android = is_android
crashpad_is_fuchsia = is_fuchsia
#include "util/misc/no_cfi_icall.h"
+#if defined(OS_TIZEN)
+#include "base/logging.h"
+#endif
+
#if defined(__GLIBC__)
extern "C" {
int memfd_create(const char* name, unsigned int flags) __THROW {
static const crashpad::NoCfiIcall<decltype(memfd_create)*> next_memfd_create(
dlsym(RTLD_NEXT, "memfd_create"));
+#if !defined(OS_TIZEN)
return next_memfd_create ? next_memfd_create(name, flags)
: syscall(SYS_memfd_create, name, flags);
+#else
+ // FIXME: m94 (SYS_memfd_create not found for tizen platform)
+ if (next_memfd_create)
+ return next_memfd_create(name, flags);
+ else {
+ LOG(ERROR) << " Undefined SYS_memfd_create for Tizen ";
+ return 0;
+ }
+#endif
}
} // extern "C"
// TODO(crbug.com/1052397): Revisit once build flag switch of lacros-chrome is
// complete.
-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS)
+#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS_LACROS) && !defined(OS_TIZEN)
void* CallMmap(void* addr,
size_t len,
int prot,
# This GN file is discovered by all Chromium builds, but common doesn't support
# all of Chromium's OSes so we explicitly make the target visible only on
# systems we know Dawn is able to compile on.
-if (is_win || is_linux || is_chromeos || is_mac || is_fuchsia || is_android) {
+if (is_win || is_linux || is_chromeos || is_mac || is_fuchsia || is_android ||
+ is_tizen) {
static_library("common") {
sources = [
"Alloc.h",
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
-import("//build/timestamp.gni")
import("../../config/gni/devtools_image_files.gni")
import("../../scripts/build/ninja/devtools_pre_built.gni")
import("../../scripts/build/ninja/node.gni")
script = "front_end/Images/generate-css-vars.js"
args = [
- build_timestamp,
rebase_path(target_gen_dir, root_build_dir),
"optimize_images",
] + devtools_image_files + devtools_src_svg_files
// found in the LICENSE file.
const path = require('path');
const {writeIfChanged} = require('../../scripts/build/ninja/write-if-changed.js');
-const [, , buildTimestamp, targetGenDir, targetName, ...imageSources] = process.argv;
+const [, , targetGenDir, targetName, ...imageSources] = process.argv;
/**
* @param {string} fileName
fileName}', import.meta.url).toString() + '\\")');`;
}
-const CURRENT_YEAR = new Date(Number(buildTimestamp) * 1000).getUTCFullYear();
+const CURRENT_YEAR = new Date().getFullYear();
const newContents = `
// Copyright ${CURRENT_YEAR} The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
const path = require('path');
const CleanCSS = require('clean-css');
const {writeIfChanged} = require('./ninja/write-if-changed.js');
-const [, , buildTimestamp, isDebugString, legacyString, targetName, srcDir, targetGenDir, files] = process.argv;
+const [, , isDebugString, legacyString, targetName, srcDir, targetGenDir, files] = process.argv;
const filenames = files.split(',');
const configFiles = [];
const generatedFileName = `${fileName}${isLegacy ? '.legacy' : ''}.js`;
const generatedFileLocation = path.join(targetGenDir, generatedFileName);
const newContents = `// Copyright ${
- new Date(Number(buildTimestamp) * 1000).getUTCFullYear()} The Chromium Authors. All rights reserved.
+ new Date().getFullYear()} The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// IMPORTANT: this file is auto generated. Please do not edit this file.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
-import("//build/timestamp.gni")
import("./node.gni")
import("./vars.gni")
[ devtools_location_prepend + "node_modules/clean-css/package.json" ]
args = [
- build_timestamp,
"$is_debug",
"${invoker.legacy}",
target_name,
#include <sys/auxv.h>
-#if !defined(ARMV8_OS_FUCHSIA)
+#if !defined(ARMV8_OS_FUCHSIA) && !defined(EWK_BRINGUP)
#define USE_HWCAP
#endif // !defined(ARMV8_OS_FUCHSIA)
# is special: that is the wayland-protocols package which defines a set of
# standardised protocols. When using the system libwayland for the client, we
# should use the manifest files provided in the sysroot.
-if (use_system_libwayland && use_sysroot) {
+if (use_system_libwayland && use_sysroot && !is_tizen) {
standard_protocol_prefix = "${sysroot}/usr/share/wayland-protocols"
} else {
standard_protocol_prefix = "src"
# This should be open to both system and non - system libwayland as
# wayland_stubs also uses this.
wayland_protocol("wayland_protocol_c") {
- if (use_system_libwayland && use_sysroot) {
+ if (use_system_libwayland && use_sysroot && !is_tizen) {
sources = [ "${sysroot}/usr/share/wayland/wayland.xml" ]
} else {
sources = [ "src/protocol/wayland.xml" ]
# Path to the wayland-scanner in the sysroot.
assert(host_os == "linux")
if (use_system_wayland_scanner) {
- if (use_sysroot) {
+ if (use_sysroot && !is_tizen) {
system_wayland_scanner_path = "$sysroot/usr/bin/wayland-scanner"
} else {
system_wayland_scanner_path = "/usr/bin/wayland-scanner"
export SCRIPTDIR=$(readlink -e $(dirname $0))
export TOPDIR=$(readlink -f "${SCRIPTDIR}/../..")
export CHROME_SRC="${TOPDIR}"
-export LATEST_TIZEN_VERSION=6.5
+export LATEST_TIZEN_VERSION=7.0
export DEFAULT_TIZEN_VERSION=$LATEST_TIZEN_VERSION
if [ "$(echo "$@" | grep -e "--tizen")" != "" ]; then
edje_dir = "/usr/share/chromium-efl/themes/"
tizen_data_dir = "/usr/share/chromium-efl/"
locale_dir = "/usr/share/chromium-efl/locale/"
+ chromium_impl_lib_name = "libchromium-ewk.so"
tizen_version = 0
tizen_version_major = 0
use_pango=false
use_cairo=false
enable_plugins=true
- enable_extensions=false
+ enable_extensions=true
use_cups=false
use_allocator=\"none\"
depth=\"${TOPDIR}\"
use_wayland=false
werror=false
dcheck_always_on=false
- enable_extensions=true
enable_nacl=false
"
}
host_cpu=\"${host_arch}\"
target_cpu=\"${host_arch}\"
use_real_dbus_clients=false
+ use_nss_certs=true
+ use_system_libwayland=true
"
# FIXME : Note that the v8_snapshot_toolchain has been set to wrong
config("content_common_efl") {
visibility = [
- "//tizen_src/chromium_impl/content/common/common_efl.gni",
"//content/*",
+ "//tizen_src/chromium_impl/content/common/common_efl.gni",
]
defines = [
"LOCALE_DIR=\"$outdir/locale\"",
]
}
+ defines += [ "CHROMIUM_IMPL_LIB_FILE=\"$chromium_impl_lib_name\"" ]
}
# Prefer using this (and excluding specific platforms) when a resource applies
# to (most) desktop platforms.
assert(toolkit_views ==
- (is_chromeos || is_fuchsia || is_linux || is_mac || is_win))
+ (is_chromeos || is_fuchsia || is_linux || is_mac || is_win || is_tizen))
# Variables that are passed to grit with the -D flag.
]
data = []
- if (!is_fuchsia && !is_android && !is_castos) {
+ if (!is_fuchsia && !is_android && !is_castos && !is_tizen) {
data_deps += [ "//chrome" ]
}
]
# Cr-Fuchsia doesn't support breakpad.
- if (!is_win && !is_fuchsia) {
+ if (!is_win && !is_fuchsia && !is_tizen) {
data_deps += [
# This is defined for Windows, but is unused by Telemetry on
# Windows, and including it can have issues when cross-compiling
]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"accelerators/menu_label_accelerator_util_linux.cc",
"accelerators/menu_label_accelerator_util_linux.h",
]
}
- if (is_chromeos_ash || (use_aura && (is_linux || is_chromeos_lacros)) ||
+ if (is_chromeos_ash ||
+ (use_aura && (is_linux || is_chromeos_lacros || is_tizen)) ||
is_fuchsia) {
sources += [
"dragdrop/os_exchange_data_provider_non_backed.cc",
if (is_chromeos_ash) {
deps += [ "//ui/base/ime/ash" ]
}
- if (is_linux || is_chromeos_lacros) {
+ if (is_linux || is_chromeos_lacros || is_tizen) {
deps += [ "//ui/base/ime/linux" ]
}
if (use_ozone) {
sources += [ "animation_win.cc" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [ "animation_linux.cc" ]
}
#include "base/time/time.h"
#include "build/build_config.h"
-#if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
+#if defined(OS_TIZEN)
+#include "third_party/libsync/src/include/sync/sync.h"
+#elif BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_ANDROID)
#include <sync/sync.h>
#endif
"drm_util_linux.h",
]
- if (is_tizen && use_aura) {
- set_sources_assignment_filter([])
- sources += [ "drm_util_linux.cc" ]
- set_sources_assignment_filter(sources_assignment_filter)
- }
-
deps = [
"//base:base",
"//build/config/linux/libdrm",
if (is_linux || is_chromeos || use_ozone) {
enabled_features = [ "supports_native_pixmap" ]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
enabled_features += [ "is_linux_or_chromeos_ash" ]
}
public_deps = [ "//mojo/public/mojom/base" ]
#include "base/android/build_info.h"
#endif
-#if BUILDFLAG(IS_LINUX)
+#if defined(OS_TIZEN)
+#include "third_party/angle/src/gpu_info_util/SystemInfo.h"
+#include "third_party/vulkan-deps/vulkan-headers/src/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
#endif
import("//build/config/linux/gtk/gtk.gni")
import("//ui/qt/qt.gni")
-assert(is_linux)
+assert(is_linux || is_tizen)
component("linux_ui") {
defines = [ "IS_LINUX_UI_IMPL" ]
scoped_refptr<gfx::NativePixmap> SurfaceFactoryCast::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
scoped_refptr<gfx::NativePixmap> GbmSurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
std::move(framebuffer));
}
-void GbmSurfaceFactory::CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
- gfx::Size size,
- gfx::BufferFormat format,
- gfx::BufferUsage usage,
- NativePixmapCallback callback) {
+void GbmSurfaceFactory::CreateNativePixmapAsync(
+ gfx::AcceleratedWidget widget,
+ gpu::VulkanDeviceQueue* device_queue,
+ gfx::Size size,
+ gfx::BufferFormat format,
+ gfx::BufferUsage usage,
+ NativePixmapCallback callback) {
drm_thread_proxy_->CreateBufferAsync(
widget, size, format, usage, 0 /* flags */,
base::BindOnce(OnNativePixmapCreated, std::move(callback),
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size = absl::nullopt) override;
void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
#include "base/fuchsia/fuchsia_logging.h"
#include "base/fuchsia/process_context.h"
#include "base/memory/ptr_util.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
#include "third_party/angle/src/common/fuchsia_egl/fuchsia_egl.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/native_pixmap.h"
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size = absl::nullopt) override;
void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
scoped_refptr<gfx::NativePixmap> HeadlessSurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
#include "base/fuchsia/fuchsia_logging.h"
#include "base/fuchsia/process_context.h"
#include "base/memory/ptr_util.h"
+#include "gpu/vulkan/vulkan_device_queue.h"
#include "third_party/angle/src/common/fuchsia_egl/fuchsia_egl.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/native_pixmap.h"
scoped_refptr<gfx::NativePixmap> ScenicSurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size) {
DCHECK(!framebuffer_size || framebuffer_size == size);
+ VkDevice vk_device = device_queue->GetVulkanDevice();
if (widget != gfx::kNullAcceleratedWidget &&
usage == gfx::BufferUsage::SCANOUT) {
// The usage SCANOUT is for a primary plane buffer.
void ScenicSurfaceFactory::CreateNativePixmapAsync(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
NativePixmapCallback callback) {
std::move(callback).Run(
- CreateNativePixmap(widget, vk_device, size, format, usage));
+ CreateNativePixmap(widget, device_queue, size, format, usage));
}
scoped_refptr<gfx::NativePixmap>
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size = absl::nullopt) override;
void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
import("//third_party/wayland/features.gni")
import("//ui/ozone/platform/wayland/wayland.gni")
-assert(is_linux || is_chromeos_lacros)
+assert(is_linux || is_chromeos_lacros || is_tizen)
source_set("common") {
sources = [
#define EGL_PLATFORM_VULKAN_DISPLAY_MODE_HEADLESS_ANGLE 0x34A5
#endif /* EGL_ANGLE_platform_angle_vulkan */
+#if defined(OS_TIZEN)
+#include <bits/stdc++.h>
+#endif
+
namespace ui {
WaylandGLEGLUtility::WaylandGLEGLUtility() = default;
scoped_refptr<gfx::NativePixmap> WaylandSurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
void WaylandSurfaceFactory::CreateNativePixmapAsync(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
// CreateNativePixmap is non-blocking operation. Thus, it is safe to call it
// and return the result with the provided callback.
std::move(callback).Run(
- CreateNativePixmap(widget, vk_device, size, format, usage));
+ CreateNativePixmap(widget, device_queue, size, format, usage));
}
scoped_refptr<gfx::NativePixmap>
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size = absl::nullopt) override;
void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
void WaylandOutput::OutputHandleScale(void* data,
struct wl_output* wl_output,
int32_t factor) {
+#if defined(OS_TIZEN_TV_PRODUCT)
+ if (!factor)
+ return;
+#endif
WaylandOutput* wayland_output = static_cast<WaylandOutput*>(data);
if (wayland_output)
wayland_output->scale_factor_ = factor;
scoped_refptr<gfx::NativePixmap> X11SurfaceFactory::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
->CanCreateNativePixmapForFormat(format);
}
-void X11SurfaceFactory::CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
- gfx::Size size,
- gfx::BufferFormat format,
- gfx::BufferUsage usage,
- NativePixmapCallback callback) {
+void X11SurfaceFactory::CreateNativePixmapAsync(
+ gfx::AcceleratedWidget widget,
+ gpu::VulkanDeviceQueue* device_queue,
+ gfx::Size size,
+ gfx::BufferFormat format,
+ gfx::BufferUsage usage,
+ NativePixmapCallback callback) {
// CreateNativePixmap is non-blocking operation. Thus, it is safe to call it
// and return the result with the provided callback.
std::move(callback).Run(
- CreateNativePixmap(widget, vk_device, size, format, usage));
+ CreateNativePixmap(widget, device_queue, size, format, usage));
}
scoped_refptr<gfx::NativePixmap>
gfx::AcceleratedWidget widget) override;
scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
absl::optional<gfx::Size> framebuffer_size = absl::nullopt) override;
bool CanCreateNativePixmapForFormat(gfx::BufferFormat format) override;
void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
scoped_refptr<gfx::NativePixmap> SurfaceFactoryOzone::CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
void SurfaceFactoryOzone::CreateNativePixmapAsync(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
#include <memory>
#include <vector>
-#if defined(OS_TIZEN)
-#include "third_party/vulkan-deps/vulkan-headers/src/include/vulkan/vulkan.h"
-#else
-#include <vulkan/vulkan.h>
-#endif
-
#include "base/callback.h"
#include "base/component_export.h"
#include "base/memory/ref_counted.h"
class NativePixmap;
}
+namespace gpu {
+class VulkanDeviceQueue;
+}
+
namespace ui {
class SurfaceOzoneCanvas;
// This method can be called on any thread.
virtual scoped_refptr<gfx::NativePixmap> CreateNativePixmap(
gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
using NativePixmapCallback =
base::OnceCallback<void(scoped_refptr<gfx::NativePixmap>)>;
virtual void CreateNativePixmapAsync(gfx::AcceleratedWidget widget,
- VkDevice vk_device,
+ gpu::VulkanDeviceQueue* device_queue,
gfx::Size size,
gfx::BufferFormat format,
gfx::BufferUsage usage,
]
}
- if (is_linux || is_chromeos) {
+ if (is_linux || is_chromeos || is_tizen) {
sources += [
"extensions/desk_extension.cc",
"extensions/desk_extension.h",
"extensions/wayland_extension.h",
]
}
- if (is_linux || is_chromeos_ash) {
+ if (is_linux || is_chromeos_ash || is_tizen) {
sources += [
"extensions/x11_extension.cc",
"extensions/x11_extension.h",
sources += [ "shell_dialog_stub.cc" ]
}
- if (is_linux && !is_castos) {
+ if ((is_linux || is_tizen) && !is_castos) {
sources += [
"select_file_dialog_linux.cc",
"select_file_dialog_linux.h",
deps += [ "//chromeos/constants" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
public_deps += [ "//ui/linux:linux_ui" ]
}
sources += [ "color_chooser/color_chooser_view.cc" ]
}
- if (is_linux || is_chromeos_lacros) {
+ if (is_linux || is_chromeos_lacros || is_tizen) {
deps += [ "//ui/base/ime/linux" ]
if (!is_chromeos_lacros) {
sources += [ "controls/menu/menu_config_linux.cc" ]
public += [ "widget/desktop_aura/desktop_screen_ozone.h" ]
sources += [ "widget/desktop_aura/desktop_screen_ozone.cc" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
public += [ "widget/desktop_aura/desktop_window_tree_host_linux.h" ]
sources += [
"widget/desktop_aura/desktop_screen_ozone_linux.cc",
"//ui/base:hit_test",
]
}
- if (is_linux || is_chromeos_lacros || is_fuchsia) {
+ if (is_linux || is_chromeos_lacros || is_fuchsia || is_tizen) {
public += [
"widget/desktop_aura/desktop_window_tree_host_platform.h",
"widget/desktop_aura/window_move_client_platform.h",
]
public_deps += [ "//ui/base/dragdrop/mojom:mojom_shared" ]
}
- if (is_linux) {
+ if (is_linux || is_tizen) {
sources += [
"widget/desktop_aura/desktop_drag_drop_client_ozone_linux.cc",
"widget/desktop_aura/desktop_drag_drop_client_ozone_linux.h",
friend class cppgc::testing::OverrideEmbedderStackStateScope;
};
-class V8_NODISCARD V8_EXPORT_PRIVATE ClassNameAsHeapObjectNameScope final {
+class V8_EXPORT_PRIVATE ClassNameAsHeapObjectNameScope final {
public:
explicit ClassNameAsHeapObjectNameScope(HeapBase& heap);
~ClassNameAsHeapObjectNameScope();
projects / platform / framework / web / chromium-efl.git / commitdiff