FCHost/cmake/DownloadCEF.cmake

+# 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.
+
+# Download the CEF binary distribution for |platform| and |version| to
+# |download_dir|. The |CEF_ROOT| variable will be set in global scope pointing
+# to the extracted location.
+# Visit https://cef-builds.spotifycdn.com/index.html for the list of
+# supported platforms and versions.
+
+function(DownloadCEF platform version download_dir)
+  # Specify the binary distribution type and download directory.
+  set(CEF_DISTRIBUTION "cef_binary_${version}_${platform}")
+  set(CEF_DOWNLOAD_DIR "${download_dir}")
+
+  # The location where we expect the extracted binary distribution.
+  set(CEF_ROOT "${CEF_DOWNLOAD_DIR}/${CEF_DISTRIBUTION}" CACHE INTERNAL "CEF_ROOT")
+
+  # Download and/or extract the binary distribution if necessary.
+  if(NOT IS_DIRECTORY "${CEF_ROOT}")
+    set(CEF_DOWNLOAD_FILENAME "${CEF_DISTRIBUTION}.tar.bz2")
+    set(CEF_DOWNLOAD_PATH "${CEF_DOWNLOAD_DIR}/${CEF_DOWNLOAD_FILENAME}")
+    if(NOT EXISTS "${CEF_DOWNLOAD_PATH}")
+      set(CEF_DOWNLOAD_URL "https://cef-builds.spotifycdn.com/${CEF_DOWNLOAD_FILENAME}")
+      string(REPLACE "+" "%2B" CEF_DOWNLOAD_URL_ESCAPED ${CEF_DOWNLOAD_URL})
+
+      # Download the SHA1 hash for the binary distribution.
+      message(STATUS "Downloading ${CEF_DOWNLOAD_PATH}.sha1 from ${CEF_DOWNLOAD_URL_ESCAPED}...")
+      file(DOWNLOAD "${CEF_DOWNLOAD_URL_ESCAPED}.sha1" "${CEF_DOWNLOAD_PATH}.sha1")
+      file(READ "${CEF_DOWNLOAD_PATH}.sha1" CEF_SHA1)
+
+      # Download the binary distribution and verify the hash.
+      message(STATUS "Downloading ${CEF_DOWNLOAD_PATH}...")
+      file(
+        DOWNLOAD "${CEF_DOWNLOAD_URL_ESCAPED}" "${CEF_DOWNLOAD_PATH}"
+        EXPECTED_HASH SHA1=${CEF_SHA1}
+        SHOW_PROGRESS
+        )
+    endif()
+
+    # Extract the binary distribution.
+    message(STATUS "Extracting ${CEF_DOWNLOAD_PATH}...")
+    execute_process(
+      COMMAND ${CMAKE_COMMAND} -E tar xzf "${CEF_DOWNLOAD_DIR}/${CEF_DOWNLOAD_FILENAME}"
+      WORKING_DIRECTORY ${CEF_DOWNLOAD_DIR}
+      )
+  endif()
+endfunction()
\ No newline at end of file

FCHost/cmake/FindCEF.cmake

-# 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.
-
-#
-# This file is the CEF CMake configuration entry point and should be loaded
-# using `find_package(CEF REQUIRED)`. See the top-level CMakeLists.txt file
-# included with the CEF binary distribution for usage information.
-#
-
-# Find the CEF binary distribution root directory.
-set(_CEF_ROOT "")
-if(CEF_ROOT AND IS_DIRECTORY "${CEF_ROOT}")
-  set(_CEF_ROOT "${CEF_ROOT}")
-  set(_CEF_ROOT_EXPLICIT 1)
-else()
-  set(_ENV_CEF_ROOT "")
-  if(DEFINED ENV{CEF_ROOT})
-    file(TO_CMAKE_PATH "$ENV{CEF_ROOT}" _ENV_CEF_ROOT)
-  endif()
-  if(_ENV_CEF_ROOT AND IS_DIRECTORY "${_ENV_CEF_ROOT}")
-    set(_CEF_ROOT "${_ENV_CEF_ROOT}")
-    set(_CEF_ROOT_EXPLICIT 1)
-  endif()
-  unset(_ENV_CEF_ROOT)
-endif()
-
-if(NOT DEFINED _CEF_ROOT_EXPLICIT)
-  message(FATAL_ERROR "Must specify a CEF_ROOT value via CMake or environment variable.")
-endif()
-
-if(NOT IS_DIRECTORY "${_CEF_ROOT}/cmake")
-  message(FATAL_ERROR "No CMake bootstrap found for CEF binary distribution at: ${CEF_ROOT}.")
-endif()
-
-# Execute additional cmake files from the CEF binary distribution.
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${_CEF_ROOT}/cmake")
-include("cef_variables")
-include("cef_macros")

FCHost/cmake/cef_macros.cmake

-# 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_MACOSX)
-    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_MACOSX AND ${name_of_list}_MACOSX)
-    list(APPEND ${name_of_list} ${${name_of_list}_MACOSX})
-  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_MACOSX)
-
-# Manually process and copy over resource files.
-macro(COPY_MACOSX_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_MACOSX)
-
-
-#
-# 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_MACOSX)
-    # 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()

FCHost/cmake/cef_variables.cmake

-# 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_MACOSX 1)
-  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(CMAKE_SIZEOF_VOID_P MATCHES 8)
-    set(PROJECT_ARCH "x86_64")
-  else()
-    set(PROJECT_ARCH "x86")
-  endif()
-
-  if(OS_MACOSX)
-    # 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
-    natives_blob.bin
-    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_MACOSX)
-  # 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.11 10.10 10.9)
-    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.9")
-  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")
-  else()
-    set(CMAKE_OSX_ARCHITECTURES "i386")
-  endif()
-
-  # 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()
-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. For a list of all version numbers see
-    # https://en.wikipedia.org/wiki/Microsoft_Visual_C%2B%2B#Internal_version_numbering
-    list(APPEND supported_msvc_versions
-      1900  # VS2015 and updates 1, 2, & 3
-      1910  # VS2017 version 15.1 & 15.2
-      1911  # VS2017 version 15.3 & 15.4
-      1912  # VS2017 version 15.5
-      1913  # VS2017 version 15.6
-      1914  # VS2017 version 15.7
-      1915  # VS2017 version 15.8
-      1916  # VS2017 version 15.9
-      1920  # VS2019 version 16.0
-      1921  # VS2018 version 16.1
-      )
-    list(FIND supported_msvc_versions ${MSVC_VERSION} _index)
-    if (${_index} EQUAL -1)
-      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
-    d3dcompiler_47.dll
-    libcef.dll
-    libEGL.dll
-    libGLESv2.dll
-    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
-      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
-      dbghelp.lib
-      psapi.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()

FCHost/cmake_vs2015.bat

-@ECHO OFF
-REM Quickly rebuild 64-bit VS2015 solution/project files from the CMake files.
-
-cmake -G "Visual Studio 14 Win64"
-pause
\ No newline at end of file

FCHost/cmake_vs2019.bat

+@ECHO OFF
+REM Quickly rebuild 64-bit VS2019 solution/project files from the CMake files.
+
+cmake -G "Visual Studio 16" -A x64
+pause
\ No newline at end of file

FCHost/cmake_vs2022.bat

+@ECHO OFF
+REM Quickly rebuild 64-bit VS2022 solution/project files from the CMake files.
+
+cmake -G "Visual Studio 17" -A x64
+pause
\ No newline at end of file

FCHost/fchost/CMakeLists.txt

@@ -16,6 +16,8 @@ set(FCHOST_SRCS
   fchost_storage.h
   fchost_storage_js.cc
   fchost_storage_js.h
+  utility.cc
+  utility.h
   )
 set(FCHOST_SRCS_LINUX
   fchost_linux.cc
@@ -73,6 +75,18 @@ set(FCHOST_RESOURCES_SRCS
   ${FCHOST_RESOURCES_MAC_ENGLISH_LPROJ_SRCS}
   )
 
+function (symlink_or_copy_to_binary_dir _target _srcFile)
+  get_filename_component(_fileName "${_srcFile}" NAME)
+  if (WIN32)
+    set(action copy_if_different)
+  else()
+    set(action create_symlink)
+  endif()
+  add_custom_command(POST_BUILD
+    TARGET ${_target}
+    COMMAND ${CMAKE_COMMAND} -E ${action} "${_srcFile}" "$<TARGET_FILE_DIR:${_target}>/${_fileName}"
+    )
+endfunction()
 
 #
 # Shared configuration.
@@ -91,14 +105,19 @@ endif()
 # Determine the target output directory.
 SET_CEF_TARGET_OUT_DIR()
 
+# Executable target.
+add_executable(${CEF_TARGET} MACOSX_BUNDLE WIN32 ${FCHOST_SRCS})
+
+set(gameHTMLFile "FC_pregmod.html")
+# Link the HTML where the executable expects to find it
+symlink_or_copy_to_binary_dir(${CEF_TARGET} "${CMAKE_SOURCE_DIR}/../bin/${gameHTMLFile}")
+
 
 #
 # Linux configuration.
 #
 
 if(OS_LINUX)
-  # Executable target.
-  add_executable(${CEF_TARGET} ${FCHOST_SRCS})
   SET_EXECUTABLE_TARGET_PROPERTIES(${CEF_TARGET})
   add_dependencies(${CEF_TARGET} libcef_dll_wrapper)
   target_link_libraries(${CEF_TARGET} libcef_lib libcef_dll_wrapper ${CEF_STANDARD_LIBS})
@@ -108,11 +127,14 @@ if(OS_LINUX)
   set_target_properties(${CEF_TARGET} PROPERTIES BUILD_WITH_INSTALL_RPATH TRUE)
   set_target_properties(${CEF_TARGET} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CEF_TARGET_OUT_DIR})
 
-  # Copy binary and resource files to the target output directory.
-  COPY_FILES("${CEF_TARGET}" "${CEF_BINARY_FILES}" "${CEF_BINARY_DIR}" "${CEF_TARGET_OUT_DIR}")
+  # Copy binary files to the target output directory.
+  #COPY_FILES("${CEF_TARGET}" "${CEF_BINARY_FILES}" "${CEF_BINARY_DIR}" "${CEF_TARGET_OUT_DIR}")
+  foreach(cefBinaryFile IN LISTS CEF_BINARY_FILES)
+  symlink_or_copy_to_binary_dir(${CEF_TARGET} "${CEF_BINARY_DIR}/${cefBinaryFile}")
+  endforeach()
   COPY_FILES("${CEF_TARGET}" "${CEF_RESOURCE_FILES}" "${CEF_RESOURCE_DIR}" "${CEF_TARGET_OUT_DIR}")
   if (EXISTS "${CEF_BINARY_DIR}/libminigbm.so")
-    COPY_FILES("${CEF_TARGET}" "libminigbm.so" "${CEF_BINARY_DIR}" "${CEF_TARGET_OUT_DIR}")
+  symlink_or_copy_to_binary_dir(${CEF_TARGET} "${CEF_BINARY_DIR}/libminigbm.so")
   endif()
 endif()
 
@@ -150,7 +172,7 @@ if(OS_MACOSX)
     )
 
   # Main executable target.
-  add_executable(${CEF_TARGET} MACOSX_BUNDLE ${FCHOST_RESOURCES_SRCS} ${FCHOST_SRCS})
+  target_sources(${CEF_TARGET} ${FCHOST_RESOURCES_SRCS})
   SET_EXECUTABLE_TARGET_PROPERTIES(${CEF_TARGET})
   add_dependencies(${CEF_TARGET} libcef_dll_wrapper "${CEF_HELPER_TARGET}")
   target_link_libraries(${CEF_TARGET} libcef_dll_wrapper ${CEF_STANDARD_LIBS})
@@ -188,7 +210,6 @@ endif()
 
 if(OS_WINDOWS)
   # Executable target.
-  add_executable(${CEF_TARGET} WIN32 ${FCHOST_SRCS})
   add_dependencies(${CEF_TARGET} libcef_dll_wrapper)
   SET_EXECUTABLE_TARGET_PROPERTIES(${CEF_TARGET})
   target_link_libraries(${CEF_TARGET} libcef_lib libcef_dll_wrapper ${CEF_STANDARD_LIBS})
@@ -199,5 +220,4 @@ if(OS_WINDOWS)
   # Copy binary and resource files to the target output directory.
   COPY_FILES("${CEF_TARGET}" "${CEF_BINARY_FILES}" "${CEF_BINARY_DIR}" "${CEF_TARGET_OUT_DIR}")
   COPY_FILES("${CEF_TARGET}" "${CEF_RESOURCE_FILES}" "${CEF_RESOURCE_DIR}" "${CEF_TARGET_OUT_DIR}")
-  COPY_FILES("${CEF_TARGET}" "FC_pregmod.html" "../../bin" "${CEF_TARGET_OUT_DIR}")
 endif()

FCHost/fchost/fchost_app.cc

@@ -4,7 +4,7 @@
 
 #include "fchost_app.h"
 
-#include <string>
+#include "./utility.h"
 
 #include "include/cef_browser.h"
 #include "include/cef_command_line.h"
@@ -14,6 +14,13 @@
 #include "fchost_handler.h"
 #include "fchost_storage_js.h"
 
+#include <filesystem>
+#include <string>
+
+#if defined(OS_LINUX)
+  #include <unistd.h>
+#endif
+
 namespace {
 
 // When using the Views framework this object provides the delegate
@@ -23,7 +30,7 @@ class SimpleWindowDelegate : public CefWindowDelegate {
   explicit SimpleWindowDelegate(CefRefPtr<CefBrowserView> browser_view)
       : browser_view_(browser_view) {}
 
-  void OnWindowCreated(CefRefPtr<CefWindow> window) OVERRIDE {
+  void OnWindowCreated(CefRefPtr<CefWindow> window) override {
     // Add the browser view and show the window.
     window->AddChildView(browser_view_);
     window->Show();
@@ -32,11 +39,11 @@ class SimpleWindowDelegate : public CefWindowDelegate {
     browser_view_->RequestFocus();
   }
 
-  void OnWindowDestroyed(CefRefPtr<CefWindow> window) OVERRIDE {
-    browser_view_ = NULL;
+  void OnWindowDestroyed(CefRefPtr<CefWindow> window) override {
+    browser_view_ = nullptr;
   }
 
-  bool CanClose(CefRefPtr<CefWindow> window) OVERRIDE {
+  bool CanClose(CefRefPtr<CefWindow> window) override {
     // Allow the window to close if the browser says it's OK.
     CefRefPtr<CefBrowser> browser = browser_view_->GetBrowser();
     if (browser)
@@ -44,7 +51,7 @@ class SimpleWindowDelegate : public CefWindowDelegate {
     return true;
   }
 
-  CefSize GetPreferredSize(CefRefPtr<CefView> view) OVERRIDE {
+  CefSize GetPreferredSize(CefRefPtr<CefView> view) override {
     return CefSize(800, 600);
   }
 
@@ -55,6 +62,36 @@ class SimpleWindowDelegate : public CefWindowDelegate {
   DISALLOW_COPY_AND_ASSIGN(SimpleWindowDelegate);
 };
 
+std::filesystem::path executablePath() {
+#if defined(OS_WIN)
+  wchar_t target_path[_MAX_PATH];
+  GetModuleFileNameW(NULL, target_path, _MAX_PATH);
+  return std::filesystem::path(target_path);
+#elif defined(OS_LINUX)
+  std::string buf;
+	buf.resize(32); // initial size estimate
+
+	for (;; ) {
+		ssize_t ret = readlink("/proc/self/exe", buf.data(), buf.size());
+
+		if (ret == -1) {
+			perror("getexename() failed");
+			break;
+		}
+
+		if (static_cast<std::size_t>(ret) >= buf.size()) { // >= because we need the terminating NUL too
+			buf.resize(buf.size() * 2);
+			continue;
+		}
+
+		return buf;
+	}
+
+	return {};
+#else
+  #error "Platform-specific code required"
+#endif
+}
 }  // namespace
 
 FCHostApp::FCHostApp() {}
@@ -86,25 +123,17 @@ void FCHostApp::OnContextInitialized() {
 
   // For now, read from external file.  Probably want to make this a resource
   // at least on Windows.
+  std::filesystem::path gameHTML = executablePath().parent_path() / "FC_pregmod.html";
 #if defined(OS_WIN)
-  wchar_t target_path[_MAX_PATH];
-  GetModuleFileNameW(NULL, target_path, _MAX_PATH);
-  std::wstring url = target_path;
-  size_t pos = url.find_last_of(L"\\/");
-  url = url.substr(0, pos);
-  url += L"/FC_pregmod.html";
+  std::wstring url = gameHTML.native();
 #else
-  #error "Platform-specific code needed"
+  std::string url = "file://" + gameHTML.string();
 #endif
 
-  // Allow some access flexibility for our local file
-  browser_settings.file_access_from_file_urls = STATE_ENABLED;
-  browser_settings.universal_access_from_file_urls = STATE_ENABLED;
-
   if (use_views) {
     // Create the BrowserView.
     CefRefPtr<CefBrowserView> browser_view = CefBrowserView::CreateBrowserView(
-        handler, url, browser_settings, NULL, NULL, NULL);
+        handler, url, browser_settings, nullptr, nullptr, nullptr);
 
     // Create the Window. It will show itself after creation.
     CefWindow::CreateTopLevelWindow(new SimpleWindowDelegate(browser_view));
@@ -120,11 +149,43 @@ void FCHostApp::OnContextInitialized() {
 
     // Create the first browser window.
     CefBrowserHost::CreateBrowser(window_info, handler, url, browser_settings,
-                                  NULL, NULL);
+                                  nullptr, nullptr);
   }
 }
 
 void FCHostApp::OnContextCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context) {
-	FCHostStorageRegister(GetLocalStorePath().ToWString() + L"/FCHostPersistentStorage", context->GetGlobal());
+	FCHostStorageRegister(GetLocalStorePath() / "FCHostPersistentStorage", context->GetGlobal());
 }
 
+int FCHostApp::main(const CefMainArgs& args, CefCommandLine* commandLine)
+{
+  // Specify CEF global settings here.
+  CefSettings settings;
+
+  if (commandLine->HasSwitch("enable-chrome-runtime")) {
+    // Enable experimental Chrome runtime. See issue #2969 for details.
+    settings.chrome_runtime = true;
+  }
+
+  // Cache location is required for local storage
+  cef_string_from_path(this->GetLocalStorePath(), &settings.cache_path);
+
+  // When generating projects with CMake the CEF_USE_SANDBOX value will be defined
+  // automatically. Pass -DUSE_SANDBOX=OFF to the CMake command-line to disable
+  // use of the sandbox.
+#if !defined(CEF_USE_SANDBOX)
+    settings.no_sandbox = true;
+#endif
+
+  // Initialize CEF for the browser process.
+  CefInitialize(args, settings, this, nullptr);
+
+  // Run the CEF message loop. This will block until CefQuitMessageLoop() is
+  // called.
+  CefRunMessageLoop();
+
+  // Shut down CEF.
+  CefShutdown();
+
+  return 0;
+}

FCHost/fchost/fchost_app.h

@@ -6,6 +6,11 @@
 
 #include "include/cef_app.h"
 
+#include <filesystem>
+
+class CefMainArgs;
+class CefCommandLine;
+
 // Implement application-level callbacks for the browser process.
 class FCHostApp : public CefApp, public CefBrowserProcessHandler, public CefRenderProcessHandler {
  public:
@@ -13,19 +18,21 @@ class FCHostApp : public CefApp, public CefBrowserProcessHandler, public CefRend
 
   // CefApp methods:
   virtual CefRefPtr<CefBrowserProcessHandler> GetBrowserProcessHandler()
-      OVERRIDE {
+      override {
     return this;
   }
   virtual CefRefPtr<CefRenderProcessHandler> GetRenderProcessHandler()
-	  OVERRIDE {
+	  override {
 	  return this;
   }
 
   // CefBrowserProcessHandler methods:
-  virtual void OnContextInitialized() OVERRIDE;
-  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context) OVERRIDE;
+  virtual void OnContextInitialized() override;
+  virtual void OnContextCreated(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame, CefRefPtr<CefV8Context> context) override;
+
+  std::filesystem::path GetLocalStorePath();
 
-  CefString GetLocalStorePath();
+  int main(const CefMainArgs& args, CefCommandLine* commandLine);
 
  private:
   // Include the default reference counting implementation.

FCHost/fchost/fchost_handler.cc

@@ -9,6 +9,7 @@
 #include <fstream>
 
 #include "include/base/cef_bind.h"
+#include "include/base/cef_callback.h"
 #include "include/cef_app.h"
 #include "include/cef_parser.h"
 #include "include/views/cef_browser_view.h"
@@ -173,7 +174,7 @@ void FCHostHandler::OnLoadEnd(CefRefPtr<CefBrowser> browser,
         }", frame->GetURL(), 0);
 }
 
-void FCHostHandler::OnBeforeDownload(CefRefPtr<CefBrowser> browser,
+bool FCHostHandler::OnBeforeDownload(CefRefPtr<CefBrowser> browser,
 									 CefRefPtr<CefDownloadItem> download_item,
 									 const CefString& suggested_name,
 									 CefRefPtr< CefBeforeDownloadCallback > callback)
@@ -181,6 +182,8 @@ void FCHostHandler::OnBeforeDownload(CefRefPtr<CefBrowser> browser,
 	CEF_REQUIRE_UI_THREAD();
 
 	callback->Continue(suggested_name, true);
+
+	return true;
 }
 
 bool FCHostHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
@@ -206,7 +209,13 @@ bool FCHostHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
 			CefWindowInfo windowInfo;
 			CefBrowserSettings settings;
 			CefPoint point;
+  #if defined (OS_WIN)
 			windowInfo.SetAsPopup(browser->GetHost()->GetWindowHandle(), "DevTools");
+  #elif defined(OS_LINUX)
+			windowInfo.SetAsChild(browser->GetHost()->GetWindowHandle(), CefRect(100, 100, 800, 600));
+  #else
+			#error "Platform-specific code required"
+  #endif
 			browser->GetHost()->ShowDevTools(windowInfo, browser->GetHost()->GetClient(), settings, point);
 
 			return true;
@@ -235,10 +244,39 @@ bool FCHostHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
 }
 
 
+void FCHostHandler::OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
+	CefRefPtr<CefFrame> frame,
+	CefRefPtr<CefContextMenuParams> params,
+	CefRefPtr<CefMenuModel> model)
+{
+	CEF_REQUIRE_UI_THREAD();
+
+	if (params->HasImageContents() && params->GetSourceUrl() != "")
+		model->AddItem(MENU_ID_USER_FIRST, "Save Image...");
+}
+
+bool FCHostHandler::OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
+	CefRefPtr<CefFrame> frame,
+	CefRefPtr<CefContextMenuParams> params,
+	int command_id,
+	EventFlags event_flags)
+{
+	CEF_REQUIRE_UI_THREAD();
+
+	switch (command_id) {
+	case MENU_ID_USER_FIRST:
+		browser->GetHost()->StartDownload(params->GetSourceUrl());
+		return true;
+	default:
+		return false;
+	}
+}
+
+
 void FCHostHandler::CloseAllBrowsers(bool force_close) {
   if (!CefCurrentlyOn(TID_UI)) {
     // Execute on the UI thread.
-    CefPostTask(TID_UI, base::Bind(&FCHostHandler::CloseAllBrowsers, this,
+    CefPostTask(TID_UI, base::BindOnce(&FCHostHandler::CloseAllBrowsers, this,
                                    force_close));
     return;
   }

FCHost/fchost/fchost_handler.h

@@ -13,7 +13,9 @@ class FCHostHandler : public CefClient,
                       public CefLifeSpanHandler,
                       public CefLoadHandler,
 					  public CefDownloadHandler,
-					  public CefKeyboardHandler {
+					  public CefKeyboardHandler,
+					  public CefContextMenuHandler,
+            private CefDialogHandler {
  public:
   explicit FCHostHandler(bool use_views);
   ~FCHostHandler();
@@ -22,52 +24,73 @@ class FCHostHandler : public CefClient,
   static FCHostHandler* GetInstance();
 
   // CefClient methods:
-  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() OVERRIDE {
+  virtual CefRefPtr<CefDisplayHandler> GetDisplayHandler() override {
     return this;
   }
-  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() OVERRIDE {
+  virtual CefRefPtr<CefLifeSpanHandler> GetLifeSpanHandler() override {
     return this;
   }
-  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() OVERRIDE { return this; }
-  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() OVERRIDE { return this; }
-  virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() OVERRIDE { return this; }
-
+  virtual CefRefPtr<CefLoadHandler> GetLoadHandler() override { return this; }
+  virtual CefRefPtr<CefDownloadHandler> GetDownloadHandler() override { return this; }
+  virtual CefRefPtr<CefKeyboardHandler> GetKeyboardHandler() override { return this; }
+  virtual CefRefPtr<CefContextMenuHandler> GetContextMenuHandler() override { return this; }
+
+  CefRefPtr< CefDialogHandler > GetDialogHandler() override { return this; }
+  bool OnFileDialog(CefRefPtr<CefBrowser> browser,
+                    CefDialogHandler::FileDialogMode mode,
+                    const CefString& title,
+                    const CefString& default_file_path,
+                    const std::vector<CefString>& accept_filters,
+                    const std::vector<CefString>& accept_extensions,
+                    const std::vector<CefString>& accept_descriptions,
+                    CefRefPtr<CefFileDialogCallback> callback) override;
 
   // CefDisplayHandler methods:
   virtual void OnTitleChange(CefRefPtr<CefBrowser> browser,
-                             const CefString& title) OVERRIDE;
+                             const CefString& title) override;
   virtual bool OnConsoleMessage(CefRefPtr<CefBrowser> browser,
 							    cef_log_severity_t level,
 								const CefString& message,
 								const CefString& source,
-								int line) OVERRIDE;
+								int line) override;
 
   // CefLifeSpanHandler methods:
-  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) OVERRIDE;
-  virtual bool DoClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
-  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) OVERRIDE;
+  virtual void OnAfterCreated(CefRefPtr<CefBrowser> browser) override;
+  virtual bool DoClose(CefRefPtr<CefBrowser> browser) override;
+  virtual void OnBeforeClose(CefRefPtr<CefBrowser> browser) override;
 
   // CefLoadHandler methods:
   virtual void OnLoadError(CefRefPtr<CefBrowser> browser,
                            CefRefPtr<CefFrame> frame,
                            ErrorCode errorCode,
                            const CefString& errorText,
-                           const CefString& failedUrl) OVERRIDE;
+                           const CefString& failedUrl) override;
   virtual void OnLoadEnd(CefRefPtr<CefBrowser> browser,
                          CefRefPtr<CefFrame> frame,
-                         int httpStatusCode) OVERRIDE;
+                         int httpStatusCode) override;
 
   // CefDownloadHandler methods:
-  virtual void OnBeforeDownload(CefRefPtr<CefBrowser> browser,
+  virtual bool OnBeforeDownload(CefRefPtr<CefBrowser> browser,
 								CefRefPtr<CefDownloadItem> download_item,
 								const CefString& suggested_name,
-								CefRefPtr< CefBeforeDownloadCallback > callback) OVERRIDE;
+								CefRefPtr< CefBeforeDownloadCallback > callback) override;
 
   // CefKeyboardHandler methods:
   virtual bool OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
 							const CefKeyEvent& event,
 							CefEventHandle os_event,
-							bool* is_keyboard_shortcut) OVERRIDE;
+							bool* is_keyboard_shortcut) override;
+
+  // CefContextMenuHandler methods:
+  virtual void OnBeforeContextMenu(CefRefPtr<CefBrowser> browser,
+	  CefRefPtr<CefFrame> frame,
+	  CefRefPtr<CefContextMenuParams> params,
+	  CefRefPtr<CefMenuModel> model) override;
+  virtual bool OnContextMenuCommand(CefRefPtr<CefBrowser> browser,
+	  CefRefPtr<CefFrame> frame,
+	  CefRefPtr<CefContextMenuParams> params,
+	  int command_id,
+	  EventFlags event_flags) override;
 
   // Request that all existing browser windows close.
   void CloseAllBrowsers(bool force_close);

FCHost/fchost/fchost_handler_linux.cc

+// Copyright (c) 2014 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.
+
+#include "fchost_handler.h"
+
+#if defined(CEF_X11)
+#include <X11/Xatom.h>
+#include <X11/Xlib.h>
+#endif
+
+#include "include/base/cef_logging.h"
+#include "include/cef_browser.h"
+
+#include <cstdlib>
+#include <cstdio>
+#include <filesystem>
+#include <iomanip>
+#include <memory>
+#include <sstream>
+#include <string>
+
+// #define TRACE
+
+#ifdef TRACE
+	#include <iostream>
+#endif
+
+namespace {
+
+	std::string executeProcessAndReadStdOut(const std::string& command)
+	{
+#ifdef TRACE
+		std::cerr << "Command: " << command << std::endl;
+#endif
+		auto closer = [](FILE* fp) { ::pclose(fp); };
+		std::unique_ptr<FILE, decltype(closer)> f(::popen(command.c_str(), "r"), closer);
+		std::ostringstream output;
+		const int BUF_SIZE = 1024;
+		char buf[BUF_SIZE];
+		while(!std::feof(f.get())){
+			std::size_t read = std::fread(buf, 1, BUF_SIZE, f.get());
+			output.write(buf, static_cast<std::streamsize>(read));
+		}
+		std::string res = output.str();
+		return res.substr(0, res.size() - 1); // to clear out CR
+	}
+
+	std::string runKDialog(CefDialogHandler::FileDialogMode mode, const CefString& title, const CefString& default_file_path,
+		const std::vector<CefString>& accept_filters)
+	{
+		std::ostringstream cmdLine;
+		cmdLine << "kdialog";
+		if (!title.empty()) {
+			cmdLine << " --title " <<  std::quoted(title.ToString());
+		}
+
+#ifdef TRACE
+		std::cerr << "mode: " << std::hex << mode << std::dec << std::endl
+			<< "default_file_path: " << default_file_path << std::endl
+			<< "accept_filters: " << std::endl;
+
+		for (const auto& f: accept_filters) {
+			std::cerr << f.ToString() << std::endl;
+		}
+#endif
+
+		switch (mode) {
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN_MULTIPLE:
+				cmdLine << " --multiple"; [[fallthrough]];
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN:
+				cmdLine << " --getopenfilename";
+				break;
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_SAVE:
+				cmdLine << " --getsavefilename";
+				break;
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN_FOLDER:
+				cmdLine << " --getexistingdirectory";
+				break;
+			default:
+				break; // TODO
+		}
+
+		const std::string dsp = default_file_path.ToString();
+		if (dsp.find('/') != std::string::npos) {
+			cmdLine << ' ' << std::quoted(dsp);
+		} else {
+			// TODO save last used directory and put it here instead of $HOME
+			cmdLine << ' ' << std::quoted(std::string(getenv("HOME")) + '/' + dsp);
+		}
+
+		if (accept_filters.size()) {
+			cmdLine << " \'";
+			for (const auto& f: accept_filters) {
+				const auto s = f.ToString();
+				cmdLine << " |" << s << " file(*" << s << ')';
+			}
+			cmdLine << '\'';
+		}
+
+		return executeProcessAndReadStdOut(cmdLine.str());
+	}
+
+	std::string runZenity(CefDialogHandler::FileDialogMode mode, const CefString& title, const CefString& default_file_path,
+		const std::vector<CefString>& accept_filters)
+	{
+		std::ostringstream cmdLine;
+		cmdLine << "zenity --file-selection --confirm-overwrite";
+
+		switch (mode) {
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN_MULTIPLE:
+				cmdLine << " --multiple";
+				break;
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN:
+				// this is the implicit default mode for zenity
+				break;
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_SAVE:
+				cmdLine << " --save";
+				break;
+			case CefDialogHandler::FileDialogMode::FILE_DIALOG_OPEN_FOLDER:
+				cmdLine << " --directory";
+				break;
+			default:
+				break; // TODO ?
+		}
+
+		const std::string dsp = default_file_path.ToString();
+		if (dsp.find('/') != std::string::npos) {
+			cmdLine << " --filename=" << std::quoted(dsp);
+		} else {
+			// TODO save last used directory and put it here instead of $HOME
+			cmdLine << " --filename=" << std::quoted(std::string(getenv("HOME")) + '/' + dsp);
+		}
+
+		for (const auto& f: accept_filters) {
+			const auto s = f.ToString();
+			cmdLine << " --file-filter=\"" << s << " file | *" << s << '"';
+		}
+
+		return executeProcessAndReadStdOut(cmdLine.str());
+	}
+
+	using DialogRunFunc = std::string (*)(CefDialogHandler::FileDialogMode mode, const CefString& title, const CefString& default_file_path,
+		const std::vector<CefString>& accept_filters);
+
+	class DialogHelper {
+		public:
+			DialogHelper();
+			std::string operator()(CefDialogHandler::FileDialogMode mode, const CefString& title, const CefString& default_file_path,
+		const std::vector<CefString>& accept_filters) const
+		{
+			return func_ ? func_(mode, title, default_file_path, accept_filters) : "";
+		}
+		private:
+			DialogRunFunc func_;
+	};
+
+	DialogHelper::DialogHelper()
+	{
+		// we will try to launch kdialog or zenity
+		std::string dialogExecutable;
+		// try to determine which environment we run inside
+		const char* desktop_env = getenv("XDG_CURRENT_DESKTOP");
+		std::string desktop = desktop_env == nullptr ? "" : desktop_env;
+
+		const auto checkExeExists = [](const char* name) {
+			int ec = ::system((std::string(name) + " --help > /dev/null").c_str());
+			return ec >= 0 && ec < 127;
+		};
+
+		if (desktop == "KDE") {
+			dialogExecutable = "kdialog";
+		} else if (desktop == "GNOME") {
+			dialogExecutable = "zenity";
+		} else {
+			// well, let's check executables
+			if (checkExeExists("zenity")) {
+				dialogExecutable = "zenity";
+			} else if (checkExeExists("kdialog")){
+				dialogExecutable = "kdialog";
+			}
+		}
+
+#ifdef TRACE
+		std::cerr << "dialogExecutable: " << dialogExecutable << std::endl
+			<< "checkExeExists: " <<  checkExeExists(dialogExecutable.c_str()) << std::endl;
+#endif
+
+		if (!dialogExecutable.empty() && checkExeExists(dialogExecutable.c_str())) {
+			if (dialogExecutable == "kdialog") {
+				func_ = &runKDialog;
+			} else if (dialogExecutable == "zenity") {
+				func_ = &runZenity;
+			} else {
+				func_ = nullptr;
+			}
+		}
+	}
+
+
+}
+
+void FCHostHandler::PlatformTitleChange(CefRefPtr<CefBrowser> browser, const CefString& title) {
+	std::string titleStr(title);
+
+#if defined(CEF_X11)
+	// Retrieve the X11 display shared with Chromium.
+	::Display* display = cef_get_xdisplay();
+	DCHECK(display);
+
+	// Retrieve the X11 window handle for the browser.
+	::Window window = browser->GetHost()->GetWindowHandle();
+	if (window == kNullWindowHandle)
+		return;
+
+	// Retrieve the atoms required by the below XChangeProperty call.
+	const char* kAtoms[] = {"_NET_WM_NAME", "UTF8_STRING"};
+	Atom atoms[2];
+	int result =
+			XInternAtoms(display, const_cast<char**>(kAtoms), 2, false, atoms);
+	if (!result)
+		NOTREACHED();
+
+	// Set the window title.
+	XChangeProperty(display, window, atoms[0], atoms[1], 8, PropModeReplace,
+									reinterpret_cast<const unsigned char*>(titleStr.c_str()),
+									titleStr.size());
+
+	// TODO(erg): This is technically wrong. So XStoreName and friends expect
+	// this in Host Portable Character Encoding instead of UTF-8, which I believe
+	// is Compound Text. This shouldn't matter 90% of the time since this is the
+	// fallback to the UTF8 property above.
+	XStoreName(display, browser->GetHost()->GetWindowHandle(), titleStr.c_str());
+#endif	// defined(CEF_X11)
+}
+
+bool FCHostHandler::OnFileDialog(CefRefPtr<CefBrowser> /* browser */,
+                                 CefDialogHandler::FileDialogMode mode,
+                                 const CefString& title,
+                                 const CefString& default_file_path,
+                                 const std::vector<CefString>& accept_filters,
+                                 const std::vector<CefString>& /* accept_extensions */,
+                                 const std::vector<CefString>& /* accept_descriptions */,
+                                 CefRefPtr<CefFileDialogCallback> callback)
+{
+	static DialogHelper helper;
+
+	std::string fn = helper(mode, title, default_file_path, accept_filters);
+#ifdef TRACE
+	std::cerr << "fn: " << fn << std::endl;
+#endif
+	if (fn.empty()) {
+		callback->Cancel();
+		return false;
+	}
+
+	std::vector<CefString> selected;
+	selected.push_back(fn);
+	callback->Continue(selected);
+	return  true;
+}

FCHost/fchost/fchost_handler_win.cc

@@ -26,3 +26,15 @@ void FCHostHandler::PlatformTitleChange(CefRefPtr<CefBrowser> browser,
 
   SetWindowText(hwnd, std::wstring(title).c_str());
 }
+
+bool FCHostHandler::OnFileDialog(CefRefPtr<CefBrowser> /* browser */,
+                                 CefDialogHandler::FileDialogMode /* mode */,
+                                 const CefString& /* title */,
+                                 const CefString& /* default_file_path */,
+                                 const std::vector<CefString>& /* accept_filters */,
+                                 const std::vector<CefString>& /* accept_extensions */,
+                                 const std::vector<CefString>& /* accept_descriptions */,
+                                 CefRefPtr<CefFileDialogCallback> /* callback */)
+{
+  return false; // to display the default dialog
+}

FCHost/fchost/fchost_linux.cc

+// Copyright (c) 2013 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.
+
+#include "fchost_app.h"
+
+#if defined(CEF_X11)
+#include <X11/Xlib.h>
+#endif
+
+#include "include/base/cef_logging.h"
+#include "include/cef_command_line.h"
+
+#include <filesystem>
+
+std::filesystem::path FCHostApp::GetLocalStorePath()
+{
+  return std::filesystem::path{getenv("HOME")} / ".local" / "share" / "FreeCities_Pregmod";
+}
+
+#if defined(CEF_X11)
+namespace {
+
+int XErrorHandlerImpl(Display* display, XErrorEvent* event) {
+  LOG(WARNING) << "X error received: "
+               << "type " << event->type << ", "
+               << "serial " << event->serial << ", "
+               << "error_code " << static_cast<int>(event->error_code) << ", "
+               << "request_code " << static_cast<int>(event->request_code)
+               << ", "
+               << "minor_code " << static_cast<int>(event->minor_code);
+  return 0;
+}
+
+int XIOErrorHandlerImpl(Display* display) {
+  return 0;
+}
+
+}  // namespace
+#endif  // defined(CEF_X11)
+
+// Entry point function for all processes.
+int main(int argc, char* argv[]) {
+  // Provide CEF with command-line arguments.
+  CefMainArgs main_args(argc, argv);
+  
+  // It will create the first browser instance in OnContextInitialized() after
+  // CEF has initialized.
+  CefRefPtr<FCHostApp> app(new FCHostApp);
+
+  // CEF applications have multiple sub-processes (render, plugin, GPU, etc)
+  // that share the same executable. This function checks the command-line and,
+  // if this is a sub-process, executes the appropriate logic.
+  int exit_code = CefExecuteProcess(main_args, app, nullptr);
+  if (exit_code >= 0) {
+    // The sub-process has completed so return here.
+    return exit_code;
+  }
+
+#if defined(CEF_X11)
+  // Install xlib error handlers so that the application won't be terminated
+  // on non-fatal errors.
+  XSetErrorHandler(XErrorHandlerImpl);
+  XSetIOErrorHandler(XIOErrorHandlerImpl);
+#endif
+
+  CefRefPtr<CefCommandLine> command_line = CefCommandLine::CreateCommandLine();
+  command_line->InitFromArgv(argc, argv);
+
+  return app->main(main_args, command_line.get());
+}

FCHost/fchost/fchost_storage.cc

 #include "fchost_storage.h"
 
 #include <algorithm>
-#if defined(OS_WIN)
-#include "shlwapi.h"
-#endif
+#include <cstdio>
+#include <memory>
+#include <vector>
+
+static_assert(CEF_STRING_TYPE_UTF16);
+
+namespace fs = std::filesystem;
+
+namespace {
+	struct closeFile {
+		void operator()(std::FILE* f) const noexcept
+		{
+			std::fclose(f);
+		}
+	};
+}
 
 CefRefPtr<CefV8Value> FCHostSessionStorage::keys() const
 {
@@ -17,7 +30,6 @@ CefRefPtr<CefV8Value> FCHostSessionStorage::keys() const
 	return ret;
 }
 
-#if defined(OS_WIN)
 /* This shouldn't happen, so don't waste time on it. Sugarcube really only writes simple alphanumeric keys.
 static bool SanitizePath(std::wstring& inpath)
 {
@@ -31,96 +43,100 @@ static bool SanitizePath(std::wstring& inpath)
 }
 */
 
+FCHostPersistentStorage::FCHostPersistentStorage(const std::filesystem::path& _path)
+	: path{_path}
+{
+	ensure_folder_exists();
+	load();
+}
+
 void FCHostPersistentStorage::set(const CefString& key, CefRefPtr<CefV8Value> val)
 {
-	__super::set(key, val);
+	base::set(key, val);
 
 	// only strings get persisted (should be OK, Sugarcube will serialize first)
 	if (val->IsString())
 	{
 		// we should probably be doing this async but TBT Sugarcube is the slow part, not the file IO
-		DWORD written;
-		HANDLE fh = CreateFile(get_filename(key).c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+		std::unique_ptr<std::FILE, closeFile> fh;
+#if defined(OS_WIN)
+		fh.reset(_wfopen(get_filename(key).c_str(), L"wb"));
+#else
+		fh.reset(std::fopen(get_filename(key).c_str(), "wb"));
+#endif
 		CefString valStr = val->GetStringValue();
-		if (valStr.size() > 0)
-		{
-			WriteFile(fh, valStr.c_str(), static_cast<DWORD>(valStr.size() * sizeof(valStr.c_str()[0])), &written, NULL);
+		if (valStr.size() > 0) {
+			std::fwrite(valStr.c_str(), static_cast<size_t>(valStr.size() * sizeof(valStr.c_str()[0])), 1, fh.get());
 		}
-		CloseHandle(fh);
 	}
 }
 
 bool FCHostPersistentStorage::remove(const CefString& key)
 {
-	bool retval = __super::remove(key);
-
-	DeleteFile(get_filename(key).c_str());
-
-	return retval;
+	fs::remove(get_filename(key));
+	return base::remove(key);
 }
 
 void FCHostPersistentStorage::clear()
 {
-	__super::clear();
-
-	WIN32_FIND_DATAW w32fd;
-	HANDLE hFind = FindFirstFile((path + L"\\*").c_str(), &w32fd);
-	if (hFind != INVALID_HANDLE_VALUE)
-	{
-		do
-		{
-			if (w32fd.dwFileAttributes & ~(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE))
-			{
-				DeleteFile(get_filename(w32fd.cFileName).c_str());
-			}
-		} while (FindNextFile(hFind, &w32fd));
-		FindClose(hFind);
+	for (const auto& entry: fs::directory_iterator(path)) {
+		if (fs::is_regular_file(entry.path())) {
+			fs::remove_all(entry.path());
+		}
 	}
+	base::clear();
 }
 
 void FCHostPersistentStorage::load()
 {
-	constexpr size_t bufsize = 1024 * 1024 * 1024; // 1gb should be enough
-	char* readbuf = new char[bufsize];
-	WIN32_FIND_DATAW w32fd;
-	HANDLE hFind = FindFirstFile((path + L"\\*").c_str(), &w32fd);
-	if (hFind != INVALID_HANDLE_VALUE)
-	{
-		do
-		{
-			if (w32fd.dwFileAttributes & ~(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_DEVICE))
-			{
-				DWORD bytesread = 0;
-				HANDLE fh = CreateFile(get_filename(w32fd.cFileName).c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-				if (fh)
-				{
-					BOOL success = ReadFile(fh, readbuf, static_cast<DWORD>(bufsize - 1), &bytesread, NULL);
-					if (success)
-					{
-						readbuf[bytesread] = L'\0';
-						readbuf[bytesread+1] = L'\0'; // null terminate
-						CefString val = reinterpret_cast<wchar_t*>(readbuf);
-						storage.emplace(w32fd.cFileName, CefV8Value::CreateString(val));
-					}
-					CloseHandle(fh);
+	std::vector<char> readbuf;
+
+	std::unique_ptr<std::FILE, closeFile> fh;
+	for (const auto& entry: fs::directory_iterator(path)) {
+		if (fs::is_regular_file(entry.path())) {
+			const auto entrySize = fs::file_size(entry.path());
+			readbuf.resize(static_cast<std::size_t>(entrySize + 2)); // +1 char16
+
+#if defined(OS_WIN)
+			fh.reset(_wfopen(entry.path().c_str(), L"rb"));
+#else
+			fh.reset(std::fopen(entry.path().c_str(), "rb"));
+#endif
+			if (std::fread(&readbuf[0], entrySize, 1, fh.get())) {
+				readbuf[entrySize + 1] = readbuf[entrySize] = 0; // null terminate
+				CefString val;
+				val.FromString16(static_cast<const char16_t*>(static_cast<const void*>(readbuf.data())));
+				auto sKey = entry.path().filename().native();
+#if defined(OS_WIN)
+				// put the fucking colon back in it
+				const size_t loc = sKey.find(L'#', 0);
+				if (loc != std::wstring::npos) {
+					sKey.replace(loc, static_cast<size_t>(1), L":");
 				}
+#endif
+				storage.emplace(sKey, CefV8Value::CreateString(val));
 			}
-		} while (FindNextFile(hFind, &w32fd));
-		FindClose(hFind);
+		}
 	}
-	delete[] readbuf;
 }
 
-std::wstring FCHostPersistentStorage::get_filename(const CefString& key) const
+fs::path FCHostPersistentStorage::get_filename(const CefString& key) const
 {
-	return path + L"\\" + key.c_str();
+#if defined (OS_WIN)
+	std::wstring sKey = key.ToWString();
+	// some fool decided to use a fucking colon as a key separator for SC V3 saves...can't have that in a filename on windows...
+	const size_t loc = sKey.find(L':', 0);
+	if (loc != std::wstring::npos) {
+		sKey.replace(loc, static_cast<size_t>(1), L"#");
+	}
+	return path / sKey;
+#else
+	return path / key.ToString();
+#endif
 }
 
 void FCHostPersistentStorage::ensure_folder_exists() const
 {
 	// ignore returned errors
-	CreateDirectory(path.c_str(), NULL);
+	fs::create_directories(path);
 }
-#else
-#error "Platform-specific persistent storage implementation required."
-#endif

FCHost/fchost/fchost_storage.h

 #pragma once
 
 #include "include/cef_app.h" // probably excessive
+
+#include <filesystem>
 #include <map>
 #include <string>
 
@@ -30,8 +32,9 @@ protected:
 // memory-backed, disk-persistent local storage
 class FCHostPersistentStorage : public FCHostSessionStorage
 {
+	using base = FCHostSessionStorage;
 public:
-	FCHostPersistentStorage(const std::wstring& _path) : path(_path) { ensure_folder_exists(); load();  };
+	FCHostPersistentStorage(const std::filesystem::path& _path);
 
 	virtual void set(const CefString& key, CefRefPtr<CefV8Value> val) override;
 	virtual bool remove(const CefString& key) override;
@@ -40,7 +43,7 @@ public:
 private:
 	void load();
 	void ensure_folder_exists() const;
-	std::wstring get_filename(const CefString& key) const;
+	std::filesystem::path get_filename(const CefString& key) const;
 
-	std::wstring path;
+	std::filesystem::path path;
 };

FCHost/fchost/fchost_storage_js.cc

@@ -24,7 +24,7 @@ static void AttachStorageFunctions(CefRefPtr<CefV8Value> object, CefRefPtr<CefV8
 	REGJSFUNC("clear");
 }
 
-void FCHostStorageRegister(const CefString& persistPath, CefRefPtr<CefV8Value> object) {
+void FCHostStorageRegister(const std::filesystem::path& persistPath, CefRefPtr<CefV8Value> object) {
 	// New context, reset everything (don't try to run more than one app at once!)
 	if (persist) persist.reset(NULL);
 	if (session) session.reset(NULL);
@@ -33,12 +33,12 @@ void FCHostStorageRegister(const CefString& persistPath, CefRefPtr<CefV8Value> o
 	session = std::make_unique<FCHostSessionStorage>();
 
 	CefRefPtr<CefV8Handler> sess_handler = new FCHostStorageHandler(false);
-	CefRefPtr<CefV8Value> obj_sess = CefV8Value::CreateObject(NULL, NULL);
+	CefRefPtr<CefV8Value> obj_sess = CefV8Value::CreateObject(nullptr, nullptr);
 	object->SetValue("FCHostSession", obj_sess, V8_PROPERTY_ATTRIBUTE_NONE);
 	AttachStorageFunctions(obj_sess, sess_handler);
 
 	CefRefPtr<CefV8Handler> pers_handler = new FCHostStorageHandler(true);
-	CefRefPtr<CefV8Value> obj_pers = CefV8Value::CreateObject(NULL, NULL);
+	CefRefPtr<CefV8Value> obj_pers = CefV8Value::CreateObject(nullptr, nullptr);
 	object->SetValue("FCHostPersistent", obj_pers, V8_PROPERTY_ATTRIBUTE_NONE);
 	AttachStorageFunctions(obj_pers, pers_handler);
 }
@@ -52,7 +52,7 @@ bool FCHostStorageHandler::Execute(const CefString& name, CefRefPtr<CefV8Value>
 
 	if (name == "size") {
 		// no arguments
-		retval = CefV8Value::CreateInt(static_cast<int32>(storage->size()));
+		retval = CefV8Value::CreateInt(static_cast<int32_t>(storage->size()));
 		return true;
 	}
 	else if (name == "keys") {

FCHost/fchost/fchost_storage_js.h

@@ -13,11 +13,11 @@ public:
 		CefRefPtr<CefV8Value> object,
 		const CefV8ValueList& arguments,
 		CefRefPtr<CefV8Value>& retval,
-		CefString& exception) OVERRIDE;
+		CefString& exception) override;
 
 private:
 	bool persistent;
 	IMPLEMENT_REFCOUNTING(FCHostStorageHandler);
 };
 
-void FCHostStorageRegister(const CefString& persistPath, CefRefPtr<CefV8Value> object);
+void FCHostStorageRegister(const std::filesystem::path& persistPath, CefRefPtr<CefV8Value> object);

FCHost/fchost/fchost_win.cc

@@ -8,14 +8,13 @@
 
 #include "fchost_app.h"
 
-CefString FCHostApp::GetLocalStorePath()
+std::filesystem::path FCHostApp::GetLocalStorePath()
 {
 	PWSTR ppath;
 	SHGetKnownFolderPath(FOLDERID_Documents, 0, NULL, &ppath);
-	std::wstring local_storage = ppath;
-	local_storage += L"\\FreeCities_Pregmod";
+	std::filesystem::path local_storage = ppath;
 	CoTaskMemFree(ppath);
-	return local_storage.c_str();
+	return local_storage / L"FreeCities_Pregmod";
 }
 
 // Entry point function for all processes.
@@ -26,9 +25,6 @@ int APIENTRY wWinMain(HINSTANCE hInstance,
   UNREFERENCED_PARAMETER(hPrevInstance);
   UNREFERENCED_PARAMETER(lpCmdLine);
 
-  // Enable High-DPI support on Windows 7 or newer.
-  CefEnableHighDPISupport();
-
   // Provide CEF with command-line arguments.
   CefMainArgs main_args(hInstance);
 
@@ -39,28 +35,14 @@ int APIENTRY wWinMain(HINSTANCE hInstance,
   // CEF applications have multiple sub-processes (render, plugin, GPU, etc)
   // that share the same executable. This function checks the command-line and,
   // if this is a sub-process, executes the appropriate logic.
-  int exit_code = CefExecuteProcess(main_args, app.get(), NULL);
+  int exit_code = CefExecuteProcess(main_args, app, nullptr);
   if (exit_code >= 0) {
     // The sub-process has completed so return here.
     return exit_code;
   }
 
-  // Specify CEF global settings here.
-  CefSettings settings;
-
-  // Cache location is required for local storage
-  CefString local_storage = app->GetLocalStorePath();
-  cef_string_from_utf16(local_storage.c_str(), local_storage.length(), &settings.cache_path);
-
-  // Initialize CEF.
-  CefInitialize(main_args, settings, app.get(), NULL);
-
-  // Run the CEF message loop. This will block until CefQuitMessageLoop() is
-  // called.
-  CefRunMessageLoop();
-
-  // Shut down CEF.
-  CefShutdown();
+  CefRefPtr<CefCommandLine> command_line = CefCommandLine::CreateCommandLine();
+  command_line->InitFromString(lpCmdLine);
 
-  return 0;
+  return app->main(main_args, command_line.get());
 }