diff --git a/FCHost/cmake/cef_macros.cmake b/FCHost/cmake/cef_macros.cmake
deleted file mode 100644
index 3ff7c15284f9aa385c81a5bfaf1e3a343e8d63ce..0000000000000000000000000000000000000000
--- a/FCHost/cmake/cef_macros.cmake
+++ /dev/null
@@ -1,366 +0,0 @@
-# Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
-# reserved. Use of this source code is governed by a BSD-style license that
-# can be found in the LICENSE file.
-
-# Must be loaded via FindCEF.cmake.
-if(NOT DEFINED _CEF_ROOT_EXPLICIT)
- message(FATAL_ERROR "Use find_package(CEF) to load this file.")
-endif()
-
-
-#
-# Shared macros.
-#
-
-# Print the current CEF configuration.
-macro(PRINT_CEF_CONFIG)
- message(STATUS "*** CEF CONFIGURATION SETTINGS ***")
- message(STATUS "Generator: ${CMAKE_GENERATOR}")
- message(STATUS "Platform: ${CMAKE_SYSTEM_NAME}")
- message(STATUS "Project architecture: ${PROJECT_ARCH}")
-
- if(GEN_NINJA OR GEN_MAKEFILES)
- message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
- endif()
-
- message(STATUS "Binary distribution root: ${_CEF_ROOT}")
-
- if(OS_MAC)
- message(STATUS "Base SDK: ${CMAKE_OSX_SYSROOT}")
- message(STATUS "Target SDK: ${CEF_TARGET_SDK}")
- endif()
-
- if(OS_WINDOWS)
- message(STATUS "Visual Studio ATL support: ${USE_ATL}")
- endif()
-
- message(STATUS "CEF sandbox: ${USE_SANDBOX}")
-
- set(_libraries ${CEF_STANDARD_LIBS})
- if(OS_WINDOWS AND USE_SANDBOX)
- list(APPEND _libraries ${CEF_SANDBOX_STANDARD_LIBS})
- endif()
- message(STATUS "Standard libraries: ${_libraries}")
-
- message(STATUS "Compile defines: ${CEF_COMPILER_DEFINES}")
- message(STATUS "Compile defines (Debug): ${CEF_COMPILER_DEFINES_DEBUG}")
- message(STATUS "Compile defines (Release): ${CEF_COMPILER_DEFINES_RELEASE}")
- message(STATUS "C compile flags: ${CEF_COMPILER_FLAGS} ${CEF_C_COMPILER_FLAGS}")
- message(STATUS "C compile flags (Debug): ${CEF_COMPILER_FLAGS_DEBUG} ${CEF_C_COMPILER_FLAGS_DEBUG}")
- message(STATUS "C compile flags (Release): ${CEF_COMPILER_FLAGS_RELEASE} ${CEF_C_COMPILER_FLAGS_RELEASE}")
- message(STATUS "C++ compile flags: ${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS}")
- message(STATUS "C++ compile flags (Debug): ${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}")
- message(STATUS "C++ compile flags (Release): ${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}")
- message(STATUS "Exe link flags: ${CEF_LINKER_FLAGS} ${CEF_EXE_LINKER_FLAGS}")
- message(STATUS "Exe link flags (Debug): ${CEF_LINKER_FLAGS_DEBUG} ${CEF_EXE_LINKER_FLAGS_DEBUG}")
- message(STATUS "Exe link flags (Release): ${CEF_LINKER_FLAGS_RELEASE} ${CEF_EXE_LINKER_FLAGS_RELEASE}")
- message(STATUS "Shared link flags: ${CEF_LINKER_FLAGS} ${CEF_SHARED_LINKER_FLAGS}")
- message(STATUS "Shared link flags (Debug): ${CEF_LINKER_FLAGS_DEBUG} ${CEF_SHARED_LINKER_FLAGS_DEBUG}")
- message(STATUS "Shared link flags (Release): ${CEF_LINKER_FLAGS_RELEASE} ${CEF_SHARED_LINKER_FLAGS_RELEASE}")
-
- if(OS_LINUX OR OS_WINDOWS)
- message(STATUS "CEF Binary files: ${CEF_BINARY_FILES}")
- message(STATUS "CEF Resource files: ${CEF_RESOURCE_FILES}")
- endif()
-endmacro()
-
-# Append platform specific sources to a list of sources.
-macro(APPEND_PLATFORM_SOURCES name_of_list)
- if(OS_LINUX AND ${name_of_list}_LINUX)
- list(APPEND ${name_of_list} ${${name_of_list}_LINUX})
- endif()
- if(OS_POSIX AND ${name_of_list}_POSIX)
- list(APPEND ${name_of_list} ${${name_of_list}_POSIX})
- endif()
- if(OS_WINDOWS AND ${name_of_list}_WINDOWS)
- list(APPEND ${name_of_list} ${${name_of_list}_WINDOWS})
- endif()
- if(OS_MAC AND ${name_of_list}_MAC)
- list(APPEND ${name_of_list} ${${name_of_list}_MAC})
- endif()
-endmacro()
-
-# Determine the target output directory based on platform and generator.
-macro(SET_CEF_TARGET_OUT_DIR)
- if(GEN_NINJA OR GEN_MAKEFILES)
- # By default Ninja and Make builds don't create a subdirectory named after
- # the configuration.
- set(CEF_TARGET_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}")
-
- # Output binaries (executables, libraries) to the correct directory.
- set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CEF_TARGET_OUT_DIR})
- set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CEF_TARGET_OUT_DIR})
- else()
- set(CEF_TARGET_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>")
- endif()
-endmacro()
-
-# Copy a list of files from one directory to another. Relative files paths are maintained.
-# The path component of the source |file_list| will be removed.
-macro(COPY_FILES target file_list source_dir target_dir)
- foreach(FILENAME ${file_list})
- set(source_file ${source_dir}/${FILENAME})
- get_filename_component(target_name ${FILENAME} NAME)
- set(target_file ${target_dir}/${target_name})
-
- string(FIND ${source_file} "$<CONFIGURATION>" _pos)
- if(NOT ${_pos} EQUAL -1)
- # Must test with an actual configuration directory.
- string(REPLACE "$<CONFIGURATION>" "Release" existing_source_file ${source_file})
- if(NOT EXISTS ${existing_source_file})
- string(REPLACE "$<CONFIGURATION>" "Debug" existing_source_file ${source_file})
- endif()
- else()
- set(existing_source_file ${source_file})
- endif()
-
- if(IS_DIRECTORY ${existing_source_file})
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E copy_directory "${source_file}" "${target_file}"
- VERBATIM
- )
- else()
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E copy_if_different "${source_file}" "${target_file}"
- VERBATIM
- )
- endif()
- endforeach()
-endmacro()
-
-
-#
-# Linux macros.
-#
-
-if(OS_LINUX)
-
-# Use pkg-config to find Linux libraries and update compiler/linker variables.
-macro(FIND_LINUX_LIBRARIES libraries)
- # Read pkg-config info into variables.
- execute_process(COMMAND pkg-config --cflags ${libraries} OUTPUT_VARIABLE FLL_CFLAGS)
- execute_process(COMMAND pkg-config --libs-only-L --libs-only-other ${libraries} OUTPUT_VARIABLE FLL_LDFLAGS)
- execute_process(COMMAND pkg-config --libs-only-l ${libraries} OUTPUT_VARIABLE FLL_LIBS)
-
- # Strip leading and trailing whitepspace.
- STRING(STRIP "${FLL_CFLAGS}" FLL_CFLAGS)
- STRING(STRIP "${FLL_LDFLAGS}" FLL_LDFLAGS)
- STRING(STRIP "${FLL_LIBS}" FLL_LIBS)
-
- # Convert to a list.
- separate_arguments(FLL_CFLAGS)
- separate_arguments(FLL_LDFLAGS)
- separate_arguments(FLL_LIBS)
-
- # Update build variables.
- list(APPEND CEF_C_COMPILER_FLAGS ${FLL_CFLAGS})
- list(APPEND CEF_CXX_COMPILER_FLAGS ${FLL_CFLAGS})
- list(APPEND CEF_EXE_LINKER_FLAGS ${FLL_LDFLAGS})
- list(APPEND CEF_SHARED_LINKER_FLAGS ${FLL_LDFLAGS})
- list(APPEND CEF_STANDARD_LIBS ${FLL_LIBS})
-endmacro()
-
-# Set SUID permissions on the specified executable.
-macro(SET_LINUX_SUID_PERMISSIONS target executable)
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E echo ""
- COMMAND ${CMAKE_COMMAND} -E echo "*** Run the following command manually to set SUID permissions ***"
- COMMAND ${CMAKE_COMMAND} -E echo "EXE=\"${executable}\" && sudo -- chown root:root $EXE && sudo -- chmod 4755 $EXE"
- COMMAND ${CMAKE_COMMAND} -E echo ""
- VERBATIM
- )
-endmacro()
-
-endif(OS_LINUX)
-
-
-#
-# Mac OS X macros.
-#
-
-if(OS_MAC)
-
-# Manually process and copy over resource files.
-macro(COPY_MAC_RESOURCES resource_list prefix_list target source_dir app_path)
- foreach(FILENAME ${resource_list})
- # Remove one or more prefixes from the source paths.
- set(TARGET_FILENAME "${FILENAME}")
- foreach(PREFIX ${prefix_list})
- string(REGEX REPLACE "^.*${PREFIX}" "" TARGET_FILENAME ${TARGET_FILENAME})
- endforeach()
-
- # Determine the absolute source and target paths.
- set(TARGET_PATH "${app_path}/Contents/Resources/${TARGET_FILENAME}")
- if(IS_ABSOLUTE ${FILENAME})
- set(SOURCE_PATH ${FILENAME})
- else()
- set(SOURCE_PATH "${source_dir}/${FILENAME}")
- endif()
-
- if(${FILENAME} MATCHES ".xib$")
- # Change the target file extension.
- string(REGEX REPLACE ".xib$" ".nib" TARGET_PATH ${TARGET_PATH})
-
- get_filename_component(TARGET_DIRECTORY ${TARGET_PATH} PATH)
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- # Create the target directory.
- COMMAND ${CMAKE_COMMAND} -E make_directory "${TARGET_DIRECTORY}"
- # Compile the XIB file to a NIB.
- COMMAND /usr/bin/ibtool --output-format binary1 --compile "${TARGET_PATH}" "${SOURCE_PATH}"
- VERBATIM
- )
- elseif(NOT ${TARGET_FILENAME} STREQUAL "Info.plist")
- # Copy the file as-is.
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E copy "${SOURCE_PATH}" "${TARGET_PATH}"
- VERBATIM
- )
- endif()
- endforeach()
-endmacro()
-
-endif(OS_MAC)
-
-
-#
-# Windows macros.
-#
-
-if(OS_WINDOWS)
-
-# Add custom manifest files to an executable target.
-macro(ADD_WINDOWS_MANIFEST manifest_path target extension)
- add_custom_command(
- TARGET ${target}
- POST_BUILD
- COMMAND "mt.exe" -nologo
- -manifest \"${manifest_path}/${target}.${extension}.manifest\" \"${manifest_path}/compatibility.manifest\"
- -outputresource:"${CEF_TARGET_OUT_DIR}/${target}.${extension}"\;\#1
- COMMENT "Adding manifest..."
- )
-endmacro()
-
-endif(OS_WINDOWS)
-
-
-#
-# Target configuration macros.
-#
-
-# Add a logical target that can be used to link the specified libraries into an
-# executable target.
-macro(ADD_LOGICAL_TARGET target debug_lib release_lib)
- add_library(${target} ${CEF_LIBTYPE} IMPORTED)
- set_target_properties(${target} PROPERTIES
- IMPORTED_LOCATION "${release_lib}"
- IMPORTED_LOCATION_DEBUG "${debug_lib}"
- IMPORTED_LOCATION_RELEASE "${release_lib}"
- )
-endmacro()
-
-# Set common target properties. Use SET_LIBRARY_TARGET_PROPERTIES() or
-# SET_EXECUTABLE_TARGET_PROPERTIES() instead of calling this macro directly.
-macro(SET_COMMON_TARGET_PROPERTIES target)
- # Compile flags.
- target_compile_options(${target} PRIVATE ${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS})
- target_compile_options(${target} PRIVATE $<$<CONFIG:Debug>:${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}>)
- target_compile_options(${target} PRIVATE $<$<CONFIG:Release>:${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}>)
-
- # Compile definitions.
- target_compile_definitions(${target} PRIVATE ${CEF_COMPILER_DEFINES})
- target_compile_definitions(${target} PRIVATE $<$<CONFIG:Debug>:${CEF_COMPILER_DEFINES_DEBUG}>)
- target_compile_definitions(${target} PRIVATE $<$<CONFIG:Release>:${CEF_COMPILER_DEFINES_RELEASE}>)
-
- # Include directories.
- target_include_directories(${target} PRIVATE ${CEF_INCLUDE_PATH})
-
- # Linker flags.
- if(CEF_LINKER_FLAGS)
- string(REPLACE ";" " " _flags_str "${CEF_LINKER_FLAGS}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS ${_flags_str})
- endif()
- if(CEF_LINKER_FLAGS_DEBUG)
- string(REPLACE ";" " " _flags_str "${CEF_LINKER_FLAGS_DEBUG}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_DEBUG ${_flags_str})
- endif()
- if(CEF_LINKER_FLAGS_RELEASE)
- string(REPLACE ";" " " _flags_str "${CEF_LINKER_FLAGS_RELEASE}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_RELEASE ${_flags_str})
- endif()
-
- if(OS_MAC)
- # Set Xcode target properties.
- set_target_properties(${target} PROPERTIES
- XCODE_ATTRIBUTE_ALWAYS_SEARCH_USER_PATHS NO
- XCODE_ATTRIBUTE_CLANG_CXX_LANGUAGE_STANDARD "gnu++11" # -std=gnu++11
- XCODE_ATTRIBUTE_CLANG_LINK_OBJC_RUNTIME NO # -fno-objc-link-runtime
- XCODE_ATTRIBUTE_CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS YES # -Wobjc-missing-property-synthesis
- XCODE_ATTRIBUTE_COPY_PHASE_STRIP NO
- XCODE_ATTRIBUTE_DEAD_CODE_STRIPPING[variant=Release] YES # -Wl,-dead_strip
- XCODE_ATTRIBUTE_GCC_C_LANGUAGE_STANDARD "c99" # -std=c99
- XCODE_ATTRIBUTE_GCC_CW_ASM_SYNTAX NO # No -fasm-blocks
- XCODE_ATTRIBUTE_GCC_DYNAMIC_NO_PIC NO
- XCODE_ATTRIBUTE_GCC_ENABLE_CPP_EXCEPTIONS NO # -fno-exceptions
- XCODE_ATTRIBUTE_GCC_ENABLE_CPP_RTTI NO # -fno-rtti
- XCODE_ATTRIBUTE_GCC_ENABLE_PASCAL_STRINGS NO # No -mpascal-strings
- XCODE_ATTRIBUTE_GCC_INLINES_ARE_PRIVATE_EXTERN YES # -fvisibility-inlines-hidden
- XCODE_ATTRIBUTE_GCC_OBJC_CALL_CXX_CDTORS YES # -fobjc-call-cxx-cdtors
- XCODE_ATTRIBUTE_GCC_SYMBOLS_PRIVATE_EXTERN YES # -fvisibility=hidden
- XCODE_ATTRIBUTE_GCC_THREADSAFE_STATICS NO # -fno-threadsafe-statics
- XCODE_ATTRIBUTE_GCC_TREAT_WARNINGS_AS_ERRORS YES # -Werror
- XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvm.clang.1_0"
- XCODE_ATTRIBUTE_GCC_WARN_ABOUT_MISSING_NEWLINE YES # -Wnewline-eof
- XCODE_ATTRIBUTE_USE_HEADERMAP NO
- OSX_ARCHITECTURES_DEBUG "${CMAKE_OSX_ARCHITECTURES}"
- OSX_ARCHITECTURES_RELEASE "${CMAKE_OSX_ARCHITECTURES}"
- )
- endif()
-endmacro()
-
-# Set library-specific properties.
-macro(SET_LIBRARY_TARGET_PROPERTIES target)
- SET_COMMON_TARGET_PROPERTIES(${target})
-
- # Shared library linker flags.
- if(CEF_SHARED_LINKER_FLAGS)
- string(REPLACE ";" " " _flags_str "${CEF_SHARED_LINKER_FLAGS}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS ${_flags_str})
- endif()
- if(CEF_SHARED_LINKER_FLAGS_DEBUG)
- string(REPLACE ";" " " _flags_str "${CEF_SHARED_LINKER_FLAGS_DEBUG}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_DEBUG ${_flags_str})
- endif()
- if(CEF_SHARED_LINKER_FLAGS_RELEASE)
- string(REPLACE ";" " " _flags_str "${CEF_SHARED_LINKER_FLAGS_RELEASE}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_RELEASE ${_flags_str})
- endif()
-endmacro()
-
-# Set executable-specific properties.
-macro(SET_EXECUTABLE_TARGET_PROPERTIES target)
- SET_COMMON_TARGET_PROPERTIES(${target})
-
- # Executable linker flags.
- if(CEF_EXE_LINKER_FLAGS)
- string(REPLACE ";" " " _flags_str "${CEF_EXE_LINKER_FLAGS}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS ${_flags_str})
- endif()
- if(CEF_EXE_LINKER_FLAGS_DEBUG)
- string(REPLACE ";" " " _flags_str "${CEF_EXE_LINKER_FLAGS_DEBUG}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_DEBUG ${_flags_str})
- endif()
- if(CEF_EXE_LINKER_FLAGS_RELEASE)
- string(REPLACE ";" " " _flags_str "${CEF_EXE_LINKER_FLAGS_RELEASE}")
- set_property(TARGET ${target} PROPERTY LINK_FLAGS_RELEASE ${_flags_str})
- endif()
-endmacro()
diff --git a/FCHost/cmake/cef_variables.cmake b/FCHost/cmake/cef_variables.cmake
deleted file mode 100644
index fb9552428e8acd4f38eba149e3bbc569a11aceee..0000000000000000000000000000000000000000
--- a/FCHost/cmake/cef_variables.cmake
+++ /dev/null
@@ -1,551 +0,0 @@
-# Copyright (c) 2016 The Chromium Embedded Framework Authors. All rights
-# reserved. Use of this source code is governed by a BSD-style license that
-# can be found in the LICENSE file.
-
-# Must be loaded via FindCEF.cmake.
-if(NOT DEFINED _CEF_ROOT_EXPLICIT)
- message(FATAL_ERROR "Use find_package(CEF) to load this file.")
-endif()
-
-
-#
-# Shared configuration.
-#
-
-# Determine the platform.
-if("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin")
- set(OS_MAC 1)
- set(OS_MACOSX 1) # For backwards compatibility.
- set(OS_POSIX 1)
-elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
- set(OS_LINUX 1)
- set(OS_POSIX 1)
-elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
- set(OS_WINDOWS 1)
-endif()
-
-# Determine the project architecture.
-if(NOT DEFINED PROJECT_ARCH)
- if(OS_WINDOWS AND "${CMAKE_GENERATOR_PLATFORM}" STREQUAL "arm64")
- set(PROJECT_ARCH "arm64")
- elseif(CMAKE_SIZEOF_VOID_P MATCHES 8)
- set(PROJECT_ARCH "x86_64")
- else()
- set(PROJECT_ARCH "x86")
- endif()
-
- if(OS_MAC)
- # PROJECT_ARCH should be specified on Mac OS X.
- message(WARNING "No PROJECT_ARCH value specified, using ${PROJECT_ARCH}")
- endif()
-endif()
-
-if(${CMAKE_GENERATOR} STREQUAL "Ninja")
- set(GEN_NINJA 1)
-elseif(${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
- set(GEN_MAKEFILES 1)
-endif()
-
-# Determine the build type.
-if(NOT CMAKE_BUILD_TYPE AND (GEN_NINJA OR GEN_MAKEFILES))
- # CMAKE_BUILD_TYPE should be specified when using Ninja or Unix Makefiles.
- set(CMAKE_BUILD_TYPE Release)
- message(WARNING "No CMAKE_BUILD_TYPE value selected, using ${CMAKE_BUILD_TYPE}")
-endif()
-
-
-# Path to the include directory.
-set(CEF_INCLUDE_PATH "${_CEF_ROOT}")
-
-# Path to the libcef_dll_wrapper target.
-set(CEF_LIBCEF_DLL_WRAPPER_PATH "${_CEF_ROOT}/libcef_dll")
-
-
-# Shared compiler/linker flags.
-list(APPEND CEF_COMPILER_DEFINES
- # Allow C++ programs to use stdint.h macros specified in the C99 standard that aren't
- # in the C++ standard (e.g. UINT8_MAX, INT64_MIN, etc)
- __STDC_CONSTANT_MACROS __STDC_FORMAT_MACROS
- )
-
-
-# Configure use of the sandbox.
-option(USE_SANDBOX "Enable or disable use of the sandbox." ON)
-
-
-#
-# Linux configuration.
-#
-
-if(OS_LINUX)
- # Platform-specific compiler/linker flags.
- set(CEF_LIBTYPE SHARED)
- list(APPEND CEF_COMPILER_FLAGS
- -fno-strict-aliasing # Avoid assumptions regarding non-aliasing of objects of different types
- -fPIC # Generate position-independent code for shared libraries
- -fstack-protector # Protect some vulnerable functions from stack-smashing (security feature)
- -funwind-tables # Support stack unwinding for backtrace()
- -fvisibility=hidden # Give hidden visibility to declarations that are not explicitly marked as visible
- --param=ssp-buffer-size=4 # Set the minimum buffer size protected by SSP (security feature, related to stack-protector)
- -pipe # Use pipes rather than temporary files for communication between build stages
- -pthread # Use the pthread library
- -Wall # Enable all warnings
- -Werror # Treat warnings as errors
- -Wno-missing-field-initializers # Don't warn about missing field initializers
- -Wno-unused-parameter # Don't warn about unused parameters
- -Wno-error=comment # Don't warn about code in comments
- -Wno-comment # Don't warn about code in comments
- )
- list(APPEND CEF_C_COMPILER_FLAGS
- -std=c99 # Use the C99 language standard
- )
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -fno-exceptions # Disable exceptions
- -fno-rtti # Disable real-time type information
- -fno-threadsafe-statics # Don't generate thread-safe statics
- -fvisibility-inlines-hidden # Give hidden visibility to inlined class member functions
- -std=gnu++11 # Use the C++11 language standard including GNU extensions
- -Wsign-compare # Warn about mixed signed/unsigned type comparisons
- )
- list(APPEND CEF_COMPILER_FLAGS_DEBUG
- -O0 # Disable optimizations
- -g # Generate debug information
- )
- list(APPEND CEF_COMPILER_FLAGS_RELEASE
- -O2 # Optimize for maximum speed
- -fdata-sections # Enable linker optimizations to improve locality of reference for data sections
- -ffunction-sections # Enable linker optimizations to improve locality of reference for function sections
- -fno-ident # Ignore the #ident directive
- -U_FORTIFY_SOURCE # Undefine _FORTIFY_SOURCE in case it was previously defined
- -D_FORTIFY_SOURCE=2 # Add memory and string function protection (security feature, related to stack-protector)
- )
- list(APPEND CEF_LINKER_FLAGS
- -fPIC # Generate position-independent code for shared libraries
- -pthread # Use the pthread library
- -Wl,--disable-new-dtags # Don't generate new-style dynamic tags in ELF
- -Wl,--fatal-warnings # Treat warnings as errors
- -Wl,-rpath,. # Set rpath so that libraries can be placed next to the executable
- -Wl,-z,noexecstack # Mark the stack as non-executable (security feature)
- -Wl,-z,now # Resolve symbols on program start instead of on first use (security feature)
- -Wl,-z,relro # Mark relocation sections as read-only (security feature)
- )
- list(APPEND CEF_LINKER_FLAGS_RELEASE
- -Wl,-O1 # Enable linker optimizations
- -Wl,--as-needed # Only link libraries that export symbols used by the binary
- -Wl,--gc-sections # Remove unused code resulting from -fdata-sections and -function-sections
- )
- list(APPEND CEF_COMPILER_DEFINES
- _FILE_OFFSET_BITS=64 # Allow the Large File Support (LFS) interface to replace the old interface
- )
- list(APPEND CEF_COMPILER_DEFINES_RELEASE
- NDEBUG # Not a debug build
- )
-
- include(CheckCCompilerFlag)
- include(CheckCXXCompilerFlag)
-
- CHECK_CXX_COMPILER_FLAG(-Wno-undefined-var-template COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
- if(COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -Wno-undefined-var-template # Don't warn about potentially uninstantiated static members
- )
- endif()
-
- CHECK_C_COMPILER_FLAG(-Wno-unused-local-typedefs COMPILER_SUPPORTS_NO_UNUSED_LOCAL_TYPEDEFS)
- if(COMPILER_SUPPORTS_NO_UNUSED_LOCAL_TYPEDEFS)
- list(APPEND CEF_C_COMPILER_FLAGS
- -Wno-unused-local-typedefs # Don't warn about unused local typedefs
- )
- endif()
-
- CHECK_CXX_COMPILER_FLAG(-Wno-literal-suffix COMPILER_SUPPORTS_NO_LITERAL_SUFFIX)
- if(COMPILER_SUPPORTS_NO_LITERAL_SUFFIX)
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -Wno-literal-suffix # Don't warn about invalid suffixes on literals
- )
- endif()
-
- CHECK_CXX_COMPILER_FLAG(-Wno-narrowing COMPILER_SUPPORTS_NO_NARROWING)
- if(COMPILER_SUPPORTS_NO_NARROWING)
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -Wno-narrowing # Don't warn about type narrowing
- )
- endif()
-
- if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -Wno-attributes # The cfi-icall attribute is not supported by the GNU C++ compiler
- )
- endif()
-
- if(PROJECT_ARCH STREQUAL "x86_64")
- # 64-bit architecture.
- list(APPEND CEF_COMPILER_FLAGS
- -m64
- -march=x86-64
- )
- list(APPEND CEF_LINKER_FLAGS
- -m64
- )
- elseif(PROJECT_ARCH STREQUAL "x86")
- # 32-bit architecture.
- list(APPEND CEF_COMPILER_FLAGS
- -msse2
- -mfpmath=sse
- -mmmx
- -m32
- )
- list(APPEND CEF_LINKER_FLAGS
- -m32
- )
- endif()
-
- # Standard libraries.
- set(CEF_STANDARD_LIBS
- X11
- )
-
- # CEF directory paths.
- set(CEF_RESOURCE_DIR "${_CEF_ROOT}/Resources")
- set(CEF_BINARY_DIR "${_CEF_ROOT}/${CMAKE_BUILD_TYPE}")
- set(CEF_BINARY_DIR_DEBUG "${_CEF_ROOT}/Debug")
- set(CEF_BINARY_DIR_RELEASE "${_CEF_ROOT}/Release")
-
- # CEF library paths.
- set(CEF_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/libcef.so")
- set(CEF_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/libcef.so")
-
- # List of CEF binary files.
- set(CEF_BINARY_FILES
- chrome-sandbox
- libcef.so
- libEGL.so
- libGLESv2.so
- snapshot_blob.bin
- v8_context_snapshot.bin
- swiftshader
- )
-
- # List of CEF resource files.
- set(CEF_RESOURCE_FILES
- cef.pak
- cef_100_percent.pak
- cef_200_percent.pak
- cef_extensions.pak
- devtools_resources.pak
- icudtl.dat
- locales
- )
-
- if(USE_SANDBOX)
- list(APPEND CEF_COMPILER_DEFINES
- CEF_USE_SANDBOX # Used by apps to test if the sandbox is enabled
- )
- endif()
-endif()
-
-
-#
-# Mac OS X configuration.
-#
-
-if(OS_MAC)
- # Platform-specific compiler/linker flags.
- # See also Xcode target properties in cef_macros.cmake.
- set(CEF_LIBTYPE SHARED)
- list(APPEND CEF_COMPILER_FLAGS
- -fno-strict-aliasing # Avoid assumptions regarding non-aliasing of objects of different types
- -fstack-protector # Protect some vulnerable functions from stack-smashing (security feature)
- -funwind-tables # Support stack unwinding for backtrace()
- -fvisibility=hidden # Give hidden visibility to declarations that are not explicitly marked as visible
- -Wall # Enable all warnings
- -Werror # Treat warnings as errors
- -Wextra # Enable additional warnings
- -Wendif-labels # Warn whenever an #else or an #endif is followed by text
- -Wnewline-eof # Warn about no newline at end of file
- -Wno-missing-field-initializers # Don't warn about missing field initializers
- -Wno-unused-parameter # Don't warn about unused parameters
- )
- list(APPEND CEF_C_COMPILER_FLAGS
- -std=c99 # Use the C99 language standard
- )
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -fno-exceptions # Disable exceptions
- -fno-rtti # Disable real-time type information
- -fno-threadsafe-statics # Don't generate thread-safe statics
- -fobjc-call-cxx-cdtors # Call the constructor/destructor of C++ instance variables in ObjC objects
- -fvisibility-inlines-hidden # Give hidden visibility to inlined class member functions
- -std=gnu++11 # Use the C++11 language standard including GNU extensions
- -Wno-narrowing # Don't warn about type narrowing
- -Wsign-compare # Warn about mixed signed/unsigned type comparisons
- )
- list(APPEND CEF_COMPILER_FLAGS_DEBUG
- -O0 # Disable optimizations
- -g # Generate debug information
- )
- list(APPEND CEF_COMPILER_FLAGS_RELEASE
- -O3 # Optimize for maximum speed plus a few extras
- )
- list(APPEND CEF_LINKER_FLAGS
- -Wl,-search_paths_first # Search for static or shared library versions in the same pass
- -Wl,-ObjC # Support creation of ObjC static libraries
- -Wl,-pie # Generate position-independent code suitable for executables only
- )
- list(APPEND CEF_LINKER_FLAGS_RELEASE
- -Wl,-dead_strip # Strip dead code
- )
-
- include(CheckCXXCompilerFlag)
-
- CHECK_CXX_COMPILER_FLAG(-Wno-undefined-var-template COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
- if(COMPILER_SUPPORTS_NO_UNDEFINED_VAR_TEMPLATE)
- list(APPEND CEF_CXX_COMPILER_FLAGS
- -Wno-undefined-var-template # Don't warn about potentially uninstantiated static members
- )
- endif()
-
- # Standard libraries.
- set(CEF_STANDARD_LIBS
- -lpthread
- "-framework Cocoa"
- "-framework AppKit"
- )
-
- # Find the newest available base SDK.
- execute_process(COMMAND xcode-select --print-path OUTPUT_VARIABLE XCODE_PATH OUTPUT_STRIP_TRAILING_WHITESPACE)
- foreach(OS_VERSION 10.15 10.14 10.13 10.12 10.11)
- set(SDK "${XCODE_PATH}/Platforms/MacOSX.platform/Developer/SDKs/MacOSX${OS_VERSION}.sdk")
- if(NOT "${CMAKE_OSX_SYSROOT}" AND EXISTS "${SDK}" AND IS_DIRECTORY "${SDK}")
- set(CMAKE_OSX_SYSROOT ${SDK})
- endif()
- endforeach()
-
- # Target SDK.
- set(CEF_TARGET_SDK "10.11")
- list(APPEND CEF_COMPILER_FLAGS
- -mmacosx-version-min=${CEF_TARGET_SDK}
- )
- set(CMAKE_OSX_DEPLOYMENT_TARGET ${CEF_TARGET_SDK})
-
- # Target architecture.
- if(PROJECT_ARCH STREQUAL "x86_64")
- set(CMAKE_OSX_ARCHITECTURES "x86_64")
- elseif(PROJECT_ARCH STREQUAL "arm64")
- set(CMAKE_OSX_ARCHITECTURES "arm64")
- else()
- set(CMAKE_OSX_ARCHITECTURES "i386")
- endif()
-
- # Prevent Xcode 11 from doing automatic codesigning.
- set(CMAKE_XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "")
-
- # CEF directory paths.
- set(CEF_BINARY_DIR "${_CEF_ROOT}/$<CONFIGURATION>")
- set(CEF_BINARY_DIR_DEBUG "${_CEF_ROOT}/Debug")
- set(CEF_BINARY_DIR_RELEASE "${_CEF_ROOT}/Release")
-
- if(USE_SANDBOX)
- list(APPEND CEF_COMPILER_DEFINES
- CEF_USE_SANDBOX # Used by apps to test if the sandbox is enabled
- )
-
- # CEF sandbox library paths.
- set(CEF_SANDBOX_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/cef_sandbox.a")
- set(CEF_SANDBOX_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/cef_sandbox.a")
- endif()
-
- # CEF Helper app suffixes.
- # Format is "<name suffix>:<target suffix>:<plist suffix>".
- set(CEF_HELPER_APP_SUFFIXES
- "::"
- " (GPU):_gpu:.gpu"
- " (Plugin):_plugin:.plugin"
- " (Renderer):_renderer:.renderer"
- )
-endif()
-
-
-#
-# Windows configuration.
-#
-
-if(OS_WINDOWS)
- if (GEN_NINJA)
- # When using the Ninja generator clear the CMake defaults to avoid excessive
- # console warnings (see issue #2120).
- set(CMAKE_CXX_FLAGS "")
- set(CMAKE_CXX_FLAGS_DEBUG "")
- set(CMAKE_CXX_FLAGS_RELEASE "")
- endif()
-
- if(USE_SANDBOX)
- # Check if the current MSVC version is compatible with the cef_sandbox.lib
- # static library. We require VS2015 or newer.
- if(MSVC_VERSION LESS 1900)
- message(WARNING "CEF sandbox is not compatible with the current MSVC version (${MSVC_VERSION})")
- set(USE_SANDBOX OFF)
- endif()
- endif()
-
- # Consumers who run into LNK4099 warnings can pass /Z7 instead (see issue #385).
- set(CEF_DEBUG_INFO_FLAG "/Zi" CACHE STRING "Optional flag specifying specific /Z flag to use")
-
- # Consumers using different runtime types may want to pass different flags
- set(CEF_RUNTIME_LIBRARY_FLAG "/MT" CACHE STRING "Optional flag specifying which runtime to use")
- if (CEF_RUNTIME_LIBRARY_FLAG)
- list(APPEND CEF_COMPILER_FLAGS_DEBUG ${CEF_RUNTIME_LIBRARY_FLAG}d)
- list(APPEND CEF_COMPILER_FLAGS_RELEASE ${CEF_RUNTIME_LIBRARY_FLAG})
- endif()
-
- # Platform-specific compiler/linker flags.
- set(CEF_LIBTYPE STATIC)
- list(APPEND CEF_COMPILER_FLAGS
- /MP # Multiprocess compilation
- /Gy # Enable function-level linking
- /GR- # Disable run-time type information
- /W4 # Warning level 4
- /WX # Treat warnings as errors
- /wd4100 # Ignore "unreferenced formal parameter" warning
- /wd4127 # Ignore "conditional expression is constant" warning
- /wd4244 # Ignore "conversion possible loss of data" warning
- /wd4481 # Ignore "nonstandard extension used: override" warning
- /wd4512 # Ignore "assignment operator could not be generated" warning
- /wd4701 # Ignore "potentially uninitialized local variable" warning
- /wd4702 # Ignore "unreachable code" warning
- /wd4996 # Ignore "function or variable may be unsafe" warning
- ${CEF_DEBUG_INFO_FLAG}
- )
- list(APPEND CEF_COMPILER_FLAGS_DEBUG
- /RTC1 # Disable optimizations
- /Od # Enable basic run-time checks
- )
- list(APPEND CEF_COMPILER_FLAGS_RELEASE
- /O2 # Optimize for maximum speed
- /Ob2 # Inline any suitable function
- /GF # Enable string pooling
- )
- list(APPEND CEF_LINKER_FLAGS_DEBUG
- /DEBUG # Generate debug information
- )
- list(APPEND CEF_EXE_LINKER_FLAGS
- /MANIFEST:NO # No default manifest (see ADD_WINDOWS_MANIFEST macro usage)
- /LARGEADDRESSAWARE # Allow 32-bit processes to access 3GB of RAM
- )
- list(APPEND CEF_COMPILER_DEFINES
- WIN32 _WIN32 _WINDOWS # Windows platform
- UNICODE _UNICODE # Unicode build
- WINVER=0x0601 _WIN32_WINNT=0x601 # Targeting Windows 7
- NOMINMAX # Use the standard's templated min/max
- WIN32_LEAN_AND_MEAN # Exclude less common API declarations
- _HAS_EXCEPTIONS=0 # Disable exceptions
- )
- list(APPEND CEF_COMPILER_DEFINES_RELEASE
- NDEBUG _NDEBUG # Not a debug build
- )
-
- # Standard libraries.
- set(CEF_STANDARD_LIBS
- comctl32.lib
- rpcrt4.lib
- shlwapi.lib
- ws2_32.lib
- )
-
- # CEF directory paths.
- set(CEF_RESOURCE_DIR "${_CEF_ROOT}/Resources")
- set(CEF_BINARY_DIR "${_CEF_ROOT}/$<CONFIGURATION>")
- set(CEF_BINARY_DIR_DEBUG "${_CEF_ROOT}/Debug")
- set(CEF_BINARY_DIR_RELEASE "${_CEF_ROOT}/Release")
-
- # CEF library paths.
- set(CEF_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/libcef.lib")
- set(CEF_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/libcef.lib")
-
- # List of CEF binary files.
- set(CEF_BINARY_FILES
- chrome_elf.dll
- libcef.dll
- libEGL.dll
- libGLESv2.dll
- snapshot_blob.bin
- v8_context_snapshot.bin
- swiftshader
- )
-
- if(NOT PROJECT_ARCH STREQUAL "arm64")
- list(APPEND CEF_BINARY_FILES
- d3dcompiler_47.dll
- )
- endif()
-
- # List of CEF resource files.
- set(CEF_RESOURCE_FILES
- cef.pak
- cef_100_percent.pak
- cef_200_percent.pak
- cef_extensions.pak
- devtools_resources.pak
- icudtl.dat
- locales
- )
-
- if(USE_SANDBOX)
- list(APPEND CEF_COMPILER_DEFINES
- PSAPI_VERSION=1 # Required by cef_sandbox.lib
- CEF_USE_SANDBOX # Used by apps to test if the sandbox is enabled
- )
-
- # Libraries required by cef_sandbox.lib.
- set(CEF_SANDBOX_STANDARD_LIBS
- Advapi32.lib
- dbghelp.lib
- Delayimp.lib
- OleAut32.lib
- PowrProf.lib
- Propsys.lib
- psapi.lib
- SetupAPI.lib
- Shell32.lib
- version.lib
- wbemuuid.lib
- winmm.lib
- )
-
- # CEF sandbox library paths.
- set(CEF_SANDBOX_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/cef_sandbox.lib")
- set(CEF_SANDBOX_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/cef_sandbox.lib")
- endif()
-
- # Configure use of ATL.
- option(USE_ATL "Enable or disable use of ATL." ON)
- if(USE_ATL)
- # Locate the atlmfc directory if it exists. It may be at any depth inside
- # the VC directory. The cl.exe path returned by CMAKE_CXX_COMPILER may also
- # be at different depths depending on the toolchain version
- # (e.g. "VC/bin/cl.exe", "VC/bin/amd64_x86/cl.exe",
- # "VC/Tools/MSVC/14.10.25017/bin/HostX86/x86/cl.exe", etc).
- set(HAS_ATLMFC 0)
- get_filename_component(VC_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)
- get_filename_component(VC_DIR_NAME ${VC_DIR} NAME)
- while(NOT ${VC_DIR_NAME} STREQUAL "VC")
- get_filename_component(VC_DIR ${VC_DIR} DIRECTORY)
- if(IS_DIRECTORY "${VC_DIR}/atlmfc")
- set(HAS_ATLMFC 1)
- break()
- endif()
- get_filename_component(VC_DIR_NAME ${VC_DIR} NAME)
- endwhile()
-
- # Determine if the Visual Studio install supports ATL.
- if(NOT HAS_ATLMFC)
- message(WARNING "ATL is not supported by your VC installation.")
- set(USE_ATL OFF)
- endif()
- endif()
-
- if(USE_ATL)
- list(APPEND CEF_COMPILER_DEFINES
- CEF_USE_ATL # Used by apps to test if ATL support is enabled
- )
- endif()
-endif()