1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
#!/usr/bin/env python
import glob
import os
import subprocess
import sys
print 'using python: ' + sys.executable + ' version: ' + sys.version
qtwebengine_src = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
chrome_src = subprocess.check_output("git config qtwebengine.chromiumsrcdir || true", shell=True).strip()
if chrome_src:
chrome_src = os.path.join(qtwebengine_src, chrome_src)
if not chrome_src or not os.path.isdir(chrome_src):
chrome_src = os.path.join(qtwebengine_src, '3rdparty/chromium')
print 'CHROMIUM_SRC_DIR not set, falling back to ' + chrome_src
script_dir = os.path.abspath(os.path.join(chrome_src, 'build'))
if not os.path.isdir(script_dir):
print script_dir + " is not a valid directory"
sys.exit(1)
root_dir = os.path.abspath(os.path.join(os.getcwd(), os.pardir))
sys.path.insert(0, script_dir)
import gyp_helper
sys.path.insert(0, os.path.join(chrome_src, 'tools', 'gyp', 'pylib'))
import gyp
# Add paths so that pymod_do_main(...) can import files.
sys.path.insert(1, os.path.join(chrome_src, 'tools', 'grit'))
sys.path.insert(1, os.path.join(chrome_src, 'tools', 'generate_shim_headers'))
sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit',
'Source', 'core', 'core.gyp', 'scripts'))
# Remove the above and keep the line below once we require a newer specific
# Chromium revision.
sys.path.insert(1, os.path.join(chrome_src, 'third_party', 'WebKit',
'Source', 'core', 'scripts'))
sys.path.insert(1, os.path.join(chrome_src, 'chrome', 'tools', 'build'))
import repack_locales
def additional_include_files(args=[]):
"""
Returns a list of additional (.gypi) files to include, without
duplicating ones that are already specified on the command line.
"""
# Determine the include files specified on the command line.
# This doesn't cover all the different option formats you can use,
# but it's mainly intended to avoid duplicating flags on the automatic
# makefile regeneration which only uses this format.
specified_includes = set()
for arg in args:
if arg.startswith('-I') and len(arg) > 2:
specified_includes.add(os.path.realpath(arg[2:]))
result = []
def AddInclude(path):
if os.path.realpath(path) not in specified_includes:
result.append(path)
# Always include common.gypi.
AddInclude(os.path.join(script_dir, 'common.gypi'))
# Used for additional build tweaks such as file exclusions
AddInclude(os.path.join(qtwebengine_src, 'build', 'qtwebengine_extras.gypi'))
# Common stuff we generate and extract from qmake
AddInclude(os.path.join(qtwebengine_src, 'build', 'qmake_extras.gypi'))
# Optionally add supplemental .gypi files if present.
supplements = glob.glob(os.path.join(chrome_src, '*', 'supplement.gypi'))
for supplement in supplements:
AddInclude(supplement)
return result
# TODO: later we probably want to hook that up with qmake to allow shadow builds. (Might not play nice with the rest of chromium though)
def get_output_dir():
outdir = os.path.join(root_dir, "out") # Hardcode for now
if not os.path.isdir(outdir):
os.mkdir(outdir)
return outdir
if __name__ == '__main__':
args = sys.argv[1:]
# On Mac we want to override CXX and CC that is provided with
# the Chromium GYP environment.
if sys.platform.startswith('darwin') and not 'GYP_CROSSCOMPILE' in os.environ:
os.environ['CXX'] = 'clang++'
os.environ['CC'] = 'clang'
gyp_helper.apply_chromium_gyp_env()
# This could give false positives since it doesn't actually do real option
# parsing. Oh well.
gyp_file_specified = False
for arg in args:
if arg.endswith('.gyp'):
gyp_file_specified = True
break
if not gyp_file_specified:
args.append(os.path.join(root_dir, 'qtwebengine.gyp'))
args.extend(['-I' + i for i in additional_include_files(args)])
# On Mac we want to build in x64 mode. And we want to use libc++.
# Even though we are not on linux, it seems we specifically have to disable linux_use_tcmalloc.
if sys.platform in ('darwin',) and not 'GYP_CROSSCOMPILE' in os.environ:
args.extend(['-D', 'host_arch=x64', '-D', 'use_libcpp=1', '-D', 'linux_use_tcmalloc=0'])
# There shouldn't be a circular dependency relationship between .gyp files,
# but in Chromium's .gyp files, on non-Mac platforms, circular relationships
# currently exist. The check for circular dependencies is currently
# bypassed on other platforms, but is left enabled on the Mac, where a
# violation of the rule causes Xcode to misbehave badly.
# TODO(mark): Find and kill remaining circular dependencies, and remove this
# option. http://crbug.com/35878.
# TODO(tc): Fix circular dependencies in ChromiumOS then add linux2 to the
# list.
if sys.platform not in ('darwin',):
args.append('--no-circular-check')
args.extend(['-D', 'webkit_src_dir=' + chrome_src + '/third_party/WebKit'])
# the top_level source directory is the first common ancestor of our module and the chromium source tree for the build to be sane.
# commonprefix works on a character basis, so it might return a phony common prefix (not the common parent directory we expect),
toplevel= os.path.commonprefix([root_dir, chrome_src])
if not os.path.exists(toplevel):
toplevel = os.path.join(toplevel, os.pardir)
args.extend(["--toplevel-dir=" + toplevel])
# Chromium specific Hack: for Chromium to build, the depth has to be set to the chromium src dir.
args.extend(["--depth=" + chrome_src])
args.extend(['-D', 'qtwebengine_src_dir=' + qtwebengine_src])
args.extend(['-D', 'chromium_src_dir=' + chrome_src])
if 'qt_cross_compile=1' in sys.argv:
os.environ['GYP_CROSSCOMPILE'] = '1'
# linux_use_gold_binary currently relies on a hardcoded relative path from chromium/src/out/(Release|Debug)
# Disable it along with the -Wl,--threads flag just in case gold isn't installed on the system.
args.extend(['-D', 'linux_use_gold_binary=0'])
args.extend(['-D', 'linux_use_gold_flags=0'])
# Trigger Qt-specific build conditions.
args.extend(['-D', 'use_qt=1'])
# Tweak the output location and format (hardcode ninja for now if not set)
args.extend(['--generator-output', os.path.abspath(get_output_dir())])
args.extend(['-Goutput_dir='+ os.path.abspath(get_output_dir())])
if not os.environ.get('GYP_GENERATORS'):
args.extend(['--format=ninja'])
if "QTWEBENGINE_GYP_DEBUG" in os.environ:
args.append("--check")
args.append("-d all")
print args
ret_code = gyp.main(args)
sys.exit(ret_code)
###################################
print 'Updating projects from gyp files...'
#sys.stdout.flush()
# Off we go...
sys.exit(gyp.main(args))
|
