582 lines
25 KiB
CMake
582 lines
25 KiB
CMake
# 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.
|
|
|
|
# OVERVIEW
|
|
#
|
|
# CMake is a cross-platform open-source build system that can generate project
|
|
# files in many different formats. It can be downloaded from
|
|
# http://www.cmake.org or installed via a platform package manager.
|
|
#
|
|
# CMake-generated project formats that have been tested with this CEF binary
|
|
# distribution include:
|
|
#
|
|
# Linux: Ninja, Unix Makefiles
|
|
# Mac OS X: Ninja, Xcode 5+
|
|
# Windows: Ninja, Visual Studio 2010+
|
|
#
|
|
# Ninja is a cross-platform open-source tool for running fast builds using
|
|
# pre-installed platform toolchains (GNU, clang, Xcode or MSVC). It can be
|
|
# downloaded from http://martine.github.io/ninja/ or installed via a platform
|
|
# package manager.
|
|
#
|
|
# CMAKE STRUCTURE
|
|
#
|
|
# This CEF binary distribution includes the following CMake files:
|
|
#
|
|
# CMakeLists.txt Bootstrap that sets up the CMake environment and
|
|
# loads the other CMake files.
|
|
# macros.cmake Helper macros for building a generic CEF-based
|
|
# application.
|
|
# libcef_dll/CMakeLists.txt Defines the libcef_dll_wrapper target.
|
|
# cefclient/CMakeLists.txt Defines the cefclient target.
|
|
# cefsimple/CMakeLists.txt Defines the cefsimple target.
|
|
#
|
|
# Existing CMake projects that use this binary distribution without changing the
|
|
# directory structure can include the existing "libcef_dll/CMakeLists.txt" file
|
|
# with minimal or no changes.
|
|
#
|
|
# BUILD REQUIREMENTS
|
|
#
|
|
# The below requirements must be met to build this CEF binary distribution.
|
|
#
|
|
# - CMake version 2.8.12.2 or newer.
|
|
#
|
|
# - Linux requirements:
|
|
# Currently supported distributions include Debian Wheezy, Ubuntu Precise, and
|
|
# related. Newer versions will likely also work but may not have been tested.
|
|
# Required packages include:
|
|
# build-essential
|
|
# libgtk2.0-dev (required by the cefclient target only)
|
|
# libgtkglext1-dev (required by the cefclient target only)
|
|
#
|
|
# - Mac OS X requirements:
|
|
# Xcode 5 or newer building on Mac OS X 10.7 (Lion) or newer. The Xcode
|
|
# command-line tools must also be installed.
|
|
#
|
|
# - Windows requirements:
|
|
# Visual Studio 2010 or newer building on Windows XP SP3 or newer. 64-bit
|
|
# version of Windows 7 or newer recommended.
|
|
#
|
|
# BUILD EXAMPLES
|
|
#
|
|
# The below commands will generate project files and create a Debug build of all
|
|
# CEF targets using CMake and the platform toolchain.
|
|
#
|
|
# Start by creating and entering the CMake build output directory:
|
|
# > cd path/to/cef_binary_*
|
|
# > mkdir build && cd build
|
|
#
|
|
# To perform a Linux build using a 32-bit CEF binary distribution on a 32-bit
|
|
# Linux platform or a 64-bit CEF binary distribution on a 64-bit Linux platform:
|
|
# Using Unix Makefiles:
|
|
# > cmake -G "Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > make -j4 cefclient cefsimple
|
|
#
|
|
# Using Ninja:
|
|
# > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > ninja cefclient cefsimple
|
|
#
|
|
# To perform a Mac OS X build using a 32-bit CEF binary distribution:
|
|
# Using the Xcode IDE:
|
|
# > cmake -G "Xcode" -DPROJECT_ARCH="i386" ..
|
|
# Open build\cef.xcodeproj in Xcode and select Product > Build.
|
|
#
|
|
# Using Ninja:
|
|
# > cmake -G "Ninja" -DPROJECT_ARCH="i386" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > ninja cefclient cefsimple
|
|
#
|
|
# To perform a Mac OS X build using a 64-bit CEF binary distribution:
|
|
# Using the Xcode IDE:
|
|
# > cmake -G "Xcode" -DPROJECT_ARCH="x86_64" ..
|
|
# Open build\cef.xcodeproj in Xcode and select Product > Build.
|
|
#
|
|
# Using Ninja:
|
|
# > cmake -G "Ninja" -DPROJECT_ARCH="x86_64" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > ninja cefclient cefsimple
|
|
#
|
|
# To perform a Windows build using a 32-bit CEF binary distribution:
|
|
# Using the Visual Studio 2013 IDE:
|
|
# > cmake -G "Visual Studio 12" ..
|
|
# Open build\cef.sln in Visual Studio and select Build > Build Solution.
|
|
#
|
|
# Using Ninja with Visual Studio 2013 command-line tools:
|
|
# (this path may be different depending on your Visual Studio installation)
|
|
# > "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat"
|
|
# > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > ninja cefclient cefsimple
|
|
#
|
|
# To perform a Windows build using a 64-bit CEF binary distribution:
|
|
# Using the Visual Studio 2013 IDE:
|
|
# > cmake -G "Visual Studio 12 Win64" ..
|
|
# Open build\cef.sln in Visual Studio and select Build > Build Solution.
|
|
#
|
|
# Using Ninja with Visual Studio 2013 command-line tools:
|
|
# (this path may be different depending on your Visual Studio installation)
|
|
# > "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64\vcvars64.bat"
|
|
# > cmake -G "Ninja" -DCMAKE_BUILD_TYPE=Debug ..
|
|
# > ninja cefclient cefsimple
|
|
|
|
#
|
|
# Shared configuration.
|
|
#
|
|
|
|
cmake_minimum_required(VERSION 2.8.12.2)
|
|
|
|
# Only generate Debug and Release configuration types.
|
|
set(CMAKE_CONFIGURATION_TYPES Debug Release)
|
|
|
|
# Project name.
|
|
project(cef)
|
|
|
|
# Use folders in the resulting project files.
|
|
set_property(GLOBAL PROPERTY OS_FOLDERS ON)
|
|
|
|
# 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(NOT CMAKE_BUILD_TYPE AND
|
|
(${CMAKE_GENERATOR} STREQUAL "Ninja" OR ${CMAKE_GENERATOR} STREQUAL "Unix 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()
|
|
|
|
# Include cmake macros.
|
|
set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}")
|
|
include("macros")
|
|
|
|
# Source include directory.
|
|
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
|
|
|
# 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).
|
|
add_definitions(-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS)
|
|
|
|
|
|
#
|
|
# Linux configuration.
|
|
#
|
|
|
|
if(OS_LINUX)
|
|
# Platform-specific compiler/linker flags.
|
|
set(CEF_LIBTYPE SHARED)
|
|
# -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
|
|
set(CEF_COMPILER_FLAGS "-fno-strict-aliasing -fPIC -fstack-protector -funwind-tables -fvisibility=hidden --param=ssp-buffer-size=4 -pipe -pthread -Wall -Werror -Wno-missing-field-initializers -Wno-unused-parameter")
|
|
# -std=c99 = Use the C99 language standard
|
|
set(CEF_C_COMPILER_FLAGS "-std=c99")
|
|
# -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
|
|
set(CEF_CXX_COMPILER_FLAGS "-fno-exceptions -fno-rtti -fno-threadsafe-statics -fvisibility-inlines-hidden -std=gnu++11 -Wsign-compare")
|
|
# -O0 = Disable optimizations
|
|
# -g = Generate debug information
|
|
set(CEF_COMPILER_FLAGS_DEBUG "-O0 -g")
|
|
# -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
|
|
# -DNDEBUG = Not a debug build
|
|
# -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)
|
|
set(CEF_COMPILER_FLAGS_RELEASE "-O2 -fdata-sections -ffunction-sections -fno-ident -DNDEBUG -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2")
|
|
# -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)
|
|
set(CEF_LINKER_FLAGS "-fPIC -pthread -Wl,--disable-new-dtags -Wl,--fatal-warnings -Wl,-rpath,. -Wl,-z,noexecstack -Wl,-z,now -Wl,-z,relro")
|
|
# -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
|
|
set(CEF_LINKER_FLAGS_RELEASE "-Wl,-O1 -Wl,--as-needed -Wl,--gc-sections")
|
|
|
|
include(CheckCCompilerFlag)
|
|
include(CheckCXXCompilerFlag)
|
|
|
|
# -Wno-unused-local-typedefs = Don't warn about unused local typedefs
|
|
CHECK_C_COMPILER_FLAG(-Wno-unused-local-typedefs COMPILER_SUPPORTS_NO_UNUSED_LOCAL_TYPEDEFS)
|
|
if(COMPILER_SUPPORTS_NO_UNUSED_LOCAL_TYPEDEFS)
|
|
set(CEF_C_COMPILER_FLAGS "${CEF_C_COMPILER_FLAGS} -Wno-unused-local-typedefs")
|
|
endif()
|
|
|
|
# -Wno-literal-suffix = Don't warn about invalid suffixes on literals
|
|
CHECK_CXX_COMPILER_FLAG(-Wno-literal-suffix COMPILER_SUPPORTS_NO_LITERAL_SUFFIX)
|
|
if(COMPILER_SUPPORTS_NO_LITERAL_SUFFIX)
|
|
set(CEF_CXX_COMPILER_FLAGS "${CEF_CXX_COMPILER_FLAGS} -Wno-literal-suffix")
|
|
endif()
|
|
|
|
# -Wno-narrowing = Don't warn about type narrowing
|
|
CHECK_CXX_COMPILER_FLAG(-Wno-narrowing COMPILER_SUPPORTS_NO_NARROWING)
|
|
if(COMPILER_SUPPORTS_NO_NARROWING)
|
|
set(CEF_CXX_COMPILER_FLAGS "${CEF_CXX_COMPILER_FLAGS} -Wno-narrowing")
|
|
endif()
|
|
|
|
if(PROJECT_ARCH STREQUAL "x86_64")
|
|
# 64-bit architecture.
|
|
set(CEF_COMPILER_FLAGS "${CEF_COMPILER_FLAGS} -m64 -march=x86-64")
|
|
set(CEF_LINKER_FLAGS "${CEF_LINKER_FLAGS} -m64")
|
|
elseif(PROJECT_ARCH STREQUAL "x86")
|
|
# 32-bit architecture.
|
|
set(CEF_COMPILER_FLAGS "${CEF_COMPILER_FLAGS} -msse2 -mfpmath=sse -mmmx -m32")
|
|
set(CEF_LINKER_FLAGS "${CEF_LINKER_FLAGS} -m32")
|
|
endif()
|
|
|
|
# Allow the Large File Support (LFS) interface to replace the old interface.
|
|
add_definitions(-D_FILE_OFFSET_BITS=64)
|
|
|
|
# Standard libraries.
|
|
set(CEF_STANDARD_LIBS "X11")
|
|
|
|
# CEF directory paths.
|
|
set(CEF_RESOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
|
|
set(CEF_BINARY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${CMAKE_BUILD_TYPE}")
|
|
set(CEF_BINARY_DIR_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/Debug")
|
|
set(CEF_BINARY_DIR_RELEASE "${CMAKE_CURRENT_SOURCE_DIR}/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
|
|
libffmpegsumo.so
|
|
libcef.so
|
|
natives_blob.bin
|
|
snapshot_blob.bin
|
|
)
|
|
|
|
# List of CEF resource files.
|
|
set(CEF_RESOURCE_FILES
|
|
cef.pak
|
|
cef_100_percent.pak
|
|
cef_200_percent.pak
|
|
devtools_resources.pak
|
|
icudtl.dat
|
|
locales
|
|
)
|
|
endif()
|
|
|
|
|
|
#
|
|
# Mac OS X configuration.
|
|
#
|
|
|
|
if(OS_MACOSX)
|
|
# Platform-specific compiler/linker flags.
|
|
# See also SET_XCODE_TARGET_PROPERTIES in macros.cmake.
|
|
set(CEF_LIBTYPE SHARED)
|
|
# -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
|
|
# -Wendif-labels = Warn whenever an #else or an #endif is followed by text
|
|
# -Werror = Treat warnings as errors
|
|
# -Wextra = Enable additional warnings
|
|
# -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
|
|
set(CEF_COMPILER_FLAGS "-fno-strict-aliasing -fstack-protector -funwind-tables -fvisibility=hidden -Wall -Wendif-labels -Werror -Wextra -Wnewline-eof -Wno-missing-field-initializers -Wno-unused-parameter")
|
|
# -std=c99 = Use the C99 language standard
|
|
set(CEF_C_COMPILER_FLAGS "-std=c99")
|
|
# -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
|
|
set(CEF_CXX_COMPILER_FLAGS "-fno-exceptions -fno-rtti -fno-threadsafe-statics -fobjc-call-cxx-cdtors -fvisibility-inlines-hidden -std=gnu++11 -Wno-narrowing -Wsign-compare")
|
|
# -O0 = Disable optimizations
|
|
# -g = Generate debug information
|
|
set(CEF_COMPILER_FLAGS_DEBUG "-O0 -g")
|
|
# -O3 = Optimize for maximum speed plus a few extras
|
|
set(CEF_COMPILER_FLAGS_RELEASE "-O3")
|
|
# -Wl,-search_paths_first = Search for static or shared library versions in the same pass
|
|
# -Wl,-ObjC = Support creation of creation of ObjC static libraries
|
|
# -Wl,-pie = Generate position-independent code suitable for executables only
|
|
set(CEF_LINKER_FLAGS "-Wl,-search_paths_first -Wl,-ObjC -Wl,-pie")
|
|
# -Wl,-dead_strip = Strip dead code
|
|
set(CEF_LINKER_FLAGS_RELEASE "-Wl,-dead_strip")
|
|
|
|
# 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.10 10.9 10.8 10.7)
|
|
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.6")
|
|
set(CEF_COMPILER_FLAGS "${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 "${CMAKE_CURRENT_SOURCE_DIR}/$<CONFIGURATION>")
|
|
set(CEF_BINARY_DIR_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/Debug")
|
|
set(CEF_BINARY_DIR_RELEASE "${CMAKE_CURRENT_SOURCE_DIR}/Release")
|
|
|
|
# CEF library paths.
|
|
set(CEF_LIB_DEBUG "${CEF_BINARY_DIR_DEBUG}/Chromium Embedded Framework.framework/Chromium Embedded Framework")
|
|
set(CEF_LIB_RELEASE "${CEF_BINARY_DIR_RELEASE}/Chromium Embedded Framework.framework/Chromium Embedded Framework")
|
|
endif()
|
|
|
|
|
|
#
|
|
# Windows configuration.
|
|
#
|
|
|
|
if(OS_WINDOWS)
|
|
# Platform-specific compiler/linker flags.
|
|
set(CEF_LIBTYPE STATIC)
|
|
# /MP = Multiprocess compilation
|
|
# /Gy = Enable function-level linking
|
|
# /GR- = Disable run-time type information
|
|
# /Zi = Enable program database
|
|
# /W4 = Warning level 4
|
|
# /WX = Treat warnings as errors
|
|
# /wd"4100" = Ignore "unreferenced formal parameter" warning
|
|
# /wd"4127" = Ignore "conditional expression is constant" warning
|
|
# /wd"4244" = Ignore "conversion possible loss of data" warning
|
|
# /wd"4512" = Ignore "assignment operator could not be generated" warning
|
|
# /wd"4701" = Ignore "potentially uninitialized local variable" warning
|
|
# /wd"4702" = Ignore "unreachable code" warning
|
|
# /wd"4996" = Ignore "function or variable may be unsafe" warning
|
|
set(CEF_COMPILER_FLAGS "/MP /Gy /GR- /Zi /W4 /WX /wd\"4100\" /wd\"4127\" /wd\"4244\" /wd\"4512\" /wd\"4701\" /wd\"4702\" /wd\"4996\"")
|
|
# /MTd = Multithreaded debug runtime
|
|
# /Od = Disable optimizations
|
|
# /RTC1 = Enable basic run-time checks
|
|
set(CEF_COMPILER_FLAGS_DEBUG "/MTd /RTC1 /Od")
|
|
# /MT = Multithreaded release runtime
|
|
# /O2 = Optimize for maximum speed
|
|
# /Ob2 = Inline any suitable function
|
|
# /GF = Enable string pooling
|
|
# /D NDEBUG /D _NDEBUG = Not a debug build
|
|
set(CEF_COMPILER_FLAGS_RELEASE "/MT /O2 /Ob2 /GF /D NDEBUG /D _NDEBUG")
|
|
# /DEBUG = Generate debug information
|
|
set(CEF_LINKER_FLAGS_DEBUG "/DEBUG")
|
|
# /MANIFEST:NO = No default manifest (see ADD_WINDOWS_MANIFEST macro usage)
|
|
set(CEF_EXE_LINKER_FLAGS "/MANIFEST:NO")
|
|
|
|
# Standard definitions
|
|
# -DWIN32 -D_WIN32 -D_WINDOWS = Windows platform
|
|
# -DUNICODE -D_UNICODE = Unicode build
|
|
# -DWINVER=0x0602 -D_WIN32_WINNT=0x602 = Targeting Windows 8
|
|
# -DNOMINMAX = Use the standard's templated min/max
|
|
# -DWIN32_LEAN_AND_MEAN = Exclude less common API declarations
|
|
# -D_HAS_EXCEPTIONS=0 = Disable exceptions
|
|
add_definitions(-DWIN32 -D_WIN32 -D_WINDOWS -DUNICODE -D_UNICODE -DWINVER=0x0602
|
|
-D_WIN32_WINNT=0x602 -DNOMINMAX -DWIN32_LEAN_AND_MEAN -D_HAS_EXCEPTIONS=0)
|
|
|
|
# Standard libraries.
|
|
set(CEF_STANDARD_LIBS "comctl32.lib" "rpcrt4.lib" "shlwapi.lib")
|
|
|
|
# CEF directory paths.
|
|
set(CEF_RESOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Resources")
|
|
set(CEF_BINARY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/$<CONFIGURATION>")
|
|
set(CEF_BINARY_DIR_DEBUG "${CMAKE_CURRENT_SOURCE_DIR}/Debug")
|
|
set(CEF_BINARY_DIR_RELEASE "${CMAKE_CURRENT_SOURCE_DIR}/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
|
|
d3dcompiler_43.dll
|
|
d3dcompiler_47.dll
|
|
ffmpegsumo.dll
|
|
libcef.dll
|
|
libEGL.dll
|
|
libGLESv2.dll
|
|
natives_blob.bin
|
|
snapshot_blob.bin
|
|
)
|
|
if(PROJECT_ARCH STREQUAL "x86")
|
|
# Only used on 32-bit platforms.
|
|
set(CEF_BINARY_FILES
|
|
${CEF_BINARY_FILES}
|
|
wow_helper.exe
|
|
)
|
|
endif()
|
|
|
|
# List of CEF resource files.
|
|
set(CEF_RESOURCE_FILES
|
|
cef.pak
|
|
cef_100_percent.pak
|
|
cef_200_percent.pak
|
|
devtools_resources.pak
|
|
icudtl.dat
|
|
locales
|
|
)
|
|
|
|
# Configure use of the sandbox.
|
|
option(USE_SANDBOX "Enable or disable use of the sandbox." ON)
|
|
if(USE_SANDBOX AND NOT MSVC_VERSION EQUAL 1800)
|
|
# The cef_sandbox.lib static library is currently built with VS2013. It will
|
|
# not link successfully with other VS versions.
|
|
set(USE_SANDBOX OFF)
|
|
endif()
|
|
|
|
if(USE_SANDBOX)
|
|
# Definition required by cef_sandbox.lib.
|
|
add_definitions(-DPSAPI_VERSION=1)
|
|
# Definition used by apps to test if the sandbox is enabled.
|
|
add_definitions(-DCEF_USE_SANDBOX)
|
|
|
|
# Libraries required by cef_sandbox.lib.
|
|
set(CEF_SANDBOX_STANDARD_LIBS "dbghelp.lib" "psapi.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)
|
|
# Determine if the Visual Studio install supports ATL.
|
|
get_filename_component(VC_BIN_DIR ${CMAKE_CXX_COMPILER} DIRECTORY)
|
|
get_filename_component(VC_DIR ${VC_BIN_DIR} DIRECTORY)
|
|
if(NOT IS_DIRECTORY "${VC_DIR}/atlmfc")
|
|
set(USE_ATL OFF)
|
|
endif()
|
|
endif()
|
|
|
|
if(USE_ATL)
|
|
# Definition used by apps to test if ATL support is enabled.
|
|
add_definitions(-DCEF_USE_ATL)
|
|
endif()
|
|
endif()
|
|
|
|
|
|
#
|
|
# Post-configuration actions.
|
|
#
|
|
|
|
# Merge compiler/linker flags.
|
|
set(CMAKE_C_FLAGS "${CEF_COMPILER_FLAGS} ${CEF_C_COMPILER_FLAGS}")
|
|
set(CMAKE_C_FLAGS_DEBUG "${CEF_COMPILER_FLAGS_DEBUG} ${CEF_C_COMPILER_FLAGS_DEBUG}")
|
|
set(CMAKE_C_FLAGS_RELEASE "${CEF_COMPILER_FLAGS_RELEASE} ${CEF_C_COMPILER_FLAGS_RELEASE}")
|
|
set(CMAKE_CXX_FLAGS "${CEF_COMPILER_FLAGS} ${CEF_CXX_COMPILER_FLAGS}")
|
|
set(CMAKE_CXX_FLAGS_DEBUG "${CEF_COMPILER_FLAGS_DEBUG} ${CEF_CXX_COMPILER_FLAGS_DEBUG}")
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CEF_COMPILER_FLAGS_RELEASE} ${CEF_CXX_COMPILER_FLAGS_RELEASE}")
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CEF_LINKER_FLAGS} ${CEF_EXE_LINKER_FLAGS}")
|
|
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CEF_LINKER_FLAGS_DEBUG} ${CEF_EXE_LINKER_FLAGS_DEBUG}")
|
|
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CEF_LINKER_FLAGS_RELEASE} ${CEF_EXE_LINKER_FLAGS_RELEASE}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CEF_LINKER_FLAGS} ${CEF_SHARED_LINKER_FLAGS}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CEF_LINKER_FLAGS_DEBUG} ${CEF_SHARED_LINKER_FLAGS_DEBUG}")
|
|
set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CEF_LINKER_FLAGS_RELEASE} ${CEF_SHARED_LINKER_FLAGS_RELEASE}")
|
|
|
|
|
|
#
|
|
# Include target subdirectories.
|
|
#
|
|
|
|
add_subdirectory(libcef_dll)
|
|
add_subdirectory(cefclient)
|
|
add_subdirectory(cefsimple)
|
|
|
|
|
|
#
|
|
# Display configuration settings.
|
|
#
|
|
|
|
message(STATUS "*** CONFIGURATION SETTINGS ***")
|
|
message(STATUS "Generator: ${CMAKE_GENERATOR}")
|
|
message(STATUS "Platform: ${CMAKE_SYSTEM_NAME}")
|
|
message(STATUS "Project architecture: ${PROJECT_ARCH}")
|
|
|
|
if(${CMAKE_GENERATOR} STREQUAL "Ninja" OR ${CMAKE_GENERATOR} STREQUAL "Unix Makefiles")
|
|
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
|
|
endif()
|
|
|
|
if(OS_MACOSX)
|
|
message(STATUS "Base SDK: ${CMAKE_OSX_SYSROOT}")
|
|
message(STATUS "Target SDK: ${CEF_TARGET_SDK}")
|
|
endif()
|
|
|
|
if(OS_WINDOWS)
|
|
message(STATUS "CEF Windows sandbox: ${USE_SANDBOX}")
|
|
message(STATUS "Visual Studio ATL support: ${USE_ATL}")
|
|
endif()
|
|
|
|
set(LIBRARIES ${CEF_STANDARD_LIBS})
|
|
if(OS_WINDOWS AND USE_SANDBOX)
|
|
set(LIBRARIES ${LIBRARIES} ${CEF_SANDBOX_STANDARD_LIBS})
|
|
endif()
|
|
message(STATUS "Standard libraries: ${LIBRARIES}")
|
|
|
|
get_directory_property(DEFINITIONS COMPILE_DEFINITIONS)
|
|
message(STATUS "Compiler definitions: ${DEFINITIONS}")
|
|
|
|
message(STATUS "C_FLAGS: ${CMAKE_C_FLAGS}")
|
|
message(STATUS "C_FLAGS_DEBUG: ${CMAKE_C_FLAGS_DEBUG}")
|
|
message(STATUS "C_FLAGS_RELEASE: ${CMAKE_C_FLAGS_RELEASE}")
|
|
message(STATUS "CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
|
|
message(STATUS "CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
|
|
message(STATUS "CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}")
|
|
message(STATUS "EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
|
|
message(STATUS "EXE_LINKER_FLAGS_DEBUG: ${CMAKE_EXE_LINKER_FLAGS_DEBUG}")
|
|
message(STATUS "EXE_LINKER_FLAGS_RELEASE: ${CMAKE_EXE_LINKER_FLAGS_RELEASE}")
|
|
message(STATUS "SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
|
|
message(STATUS "SHARED_LINKER_FLAGS_DEBUG: ${CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
|
|
message(STATUS "SHARED_LINKER_FLAGS_RELEASE: ${CMAKE_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()
|