""" Runs the specified command. """

# add depot_tools to the path

env = os.environ

if not depot_tools_dir is None:

env['PATH'] = depot_tools_dir + os.pathsep + env['PATH']

sys.stdout.write('-------- Running "'+command_line+'" in "'+\

working_dir+'"...'+"\n")

if not options.dryrun:

args = shlex.split(command_line.replace('\\', '\\\\'))

if not output_file:

return subprocess.check_call(

args, cwd=working_dir, env=env, shell=(sys.platform == 'win32'))

try:

msg('Writing %s' % output_file)

with open(output_file, "w") as f:

return subprocess.check_call(

args,

cwd=working_dir,

env=env,

shell=(sys.platform == 'win32'),

stderr=subprocess.STDOUT,

stdout=f)

except subprocess.CalledProcessError:

msg('ERROR Run failed. See %s for output.' % output_file)

""" Creates a directory if it doesn't already exist. """

if not os.path.exists(path):

msg("Creating directory %s" % (path))

if not options.dryrun:

""" Removes an existing directory. """

if os.path.exists(path):

msg("Removing directory %s" % (path))

if not options.dryrun:

""" Copies a directory from source to target. """

if not options.dryrun and os.path.exists(target):

if not allow_overwrite:

raise Exception("Directory %s already exists" % (target))

remove_directory(target)

if os.path.exists(source):

msg("Copying directory %s to %s" % (source, target))

if not options.dryrun:

""" Copies a directory from source to target. """

if not options.dryrun and os.path.exists(target):

if not allow_overwrite:

raise Exception("Directory %s already exists" % (target))

remove_directory(target)

if os.path.exists(source):

msg("Moving directory %s to %s" % (source, target))

if not options.dryrun:

""" Execute the specified command and return the result. """

out = ''

err = ''

sys.stdout.write("-------- Running \"%s\" in \"%s\"...\n" % (cmd, path))

parts = cmd.split()

try:

process = subprocess.Popen(

parts,

cwd=path,

stdout=subprocess.PIPE,

stderr=subprocess.PIPE,

shell=(sys.platform == 'win32'))

out, err = process.communicate()

except IOError:

raise

except:

raise

""" Returns the git hash for the specified branch/tag/hash. """

cmd = "%s rev-parse %s" % (git_exe, branch)

result = exec_cmd(cmd, path)

if result['out'] != '':

return result['out'].strip()

""" Returns the date for the specified branch/tag/hash. """

cmd = "%s show -s --format=%%ct %s" % (git_exe, branch)

result = exec_cmd(cmd, path)

if result['out'] != '':

return datetime.utcfromtimestamp(

int(result['out'].strip())).strftime('%Y-%m-%d %H:%M:%S UTC')

""" Returns the origin url for the specified path. """

cmd = "%s config --get remote.origin.url" % (git_exe)

result = exec_cmd(cmd, path)

if result['out'] != '':

return result['out'].strip()

""" Extracts the contents of src, which may be a URL or local file, to the

temporary = False

if src[:4] == 'http':

# Attempt to download a URL.

opener = FancyURLopener({})

response = opener.open(src)

temporary = True

handle, archive_path = tempfile.mkstemp(suffix='.zip')

os.write(handle, response.read())

os.close(handle)

elif os.path.exists(src):

# Use a local file.

archive_path = src

else:

raise Exception('Path type is unsupported or does not exist: ' + src)

if not zipfile.is_zipfile(archive_path):

raise Exception('Not a valid zip archive: ' + src)

# Attempt to extract the archive file.

try:

os.makedirs(target)

zf = zipfile.ZipFile(archive_path, 'r')

zf.extractall(target)

except:

shutil.rmtree(target, onerror=onerror)

raise

zf.close()

# Delete the archive file if temporary.

if temporary and os.path.exists(archive_path):

""" Read a file. """

if os.path.exists(path):

fp = open(path, 'r')

data = fp.read()

fp.close()

return data

else:

""" Write a configuration file. """

msg('Writing file: %s' % path)

if not options.dryrun:

fp = open(path, 'w')

fp.write("{\n")

for key in sorted(contents.keys()):

fp.write(" '%s': '%s',\n" % (key, contents[key]))

fp.write("}\n")

""" Read the CEF branch from the specified path. """

config_file = os.path.join(path, 'cef.branch')

if os.path.isfile(config_file):

contents = read_config_file(config_file)

if 'branch' in contents:

return contents['branch']

""" Write the CEF branch to the specified path. """

config_file = os.path.join(path, 'cef.branch')

if not os.path.isfile(config_file):

""" Remove an entry from the Chromium DEPS file at the specified path. """

msg('Updating DEPS file: %s' % path)

if not options.dryrun:

# Read the DEPS file.

fp = open(path, 'r')

lines = fp.readlines()

fp.close()

# Write the DEPS file.

# Each entry takes 2 lines. Skip both lines if found.

fp = open(path, 'w')

skip_next = False

for line in lines:

if skip_next:

skip_next = False

continue

elif line.find(entry) >= 0:

skip_next = True

continue

fp.write(line)

""" Patch the Chromium DEPS file if necessary. """

# Starting with 43.0.2357.126 the DEPS file is now 100% Git and the .DEPS.git

# file is no longer created. Look for the older file first in case we're

# building an older branch version.

deps_file = '.DEPS.git'

deps_path = os.path.join(chromium_src_dir, deps_file)

if not os.path.isfile(deps_path):

deps_file = 'DEPS'

deps_path = os.path.join(chromium_src_dir, deps_file)

if os.path.isfile(deps_path):

msg("Chromium DEPS file: %s" % (deps_path))

patch_file = os.path.join(cef_dir, 'patch', 'patches', deps_file)

if os.path.exists(patch_file + ".patch"):

# Attempt to apply the DEPS patch file that may exist with newer branches.

patch_tool = os.path.join(cef_dir, 'tools', 'patcher.py')

run('%s %s --patch-file "%s" --patch-dir "%s"' %

(python_exe, patch_tool, patch_file,

chromium_src_dir), chromium_src_dir, depot_tools_dir)

elif cef_branch != 'trunk' and int(cef_branch) <= 1916:

# Release branch DEPS files older than 37.0.2007.0 may include a 'src'

# entry. This entry needs to be removed otherwise `gclient sync` will

# fail.

remove_deps_entry(deps_path, "'src'")

else:

""" Run the patch updater script. """

tool = os.path.join(cef_src_dir, 'tools', 'patch_updater.py')

if len(args) > 0:

args = ' ' + args

run('%s %s%s' % (python_exe, tool, args), cef_src_dir, depot_tools_dir,

"""

import stat

if not os.access(path, os.W_OK):

# Is the error an access error ?

os.chmod(path, stat.S_IWUSR)

func(path)

else:

""" Read a JSON URL. """

msg('Downloading %s' % url)

response = urlopen(url)

""" Returns all data for the specified Chromium channel. """

global g_channel_data

if g_channel_data is None:

g_channel_data = read_json_url(chromium_channel_json_url)

assert len(g_channel_data) > 0, 'Failed to load Chromium channel data'

for oses in g_channel_data:

if oses['os'] == os:

for version in oses['versions']:

if version['channel'] == channel:

assert version['os'] == os

assert version['channel'] == channel

if param is None:

return version

else:

assert param in version, 'Missing parameter %s for Chromium channel %s %s' % (

param, os, channel)

return version[param]

raise Exception("Invalid Chromium channel value: %s" % channel)

""" Returns the closest master position for the specified Chromium commit. """

# Using -2 because a "Publish DEPS" commit which does not have a master

# position may be first.

cmd = "%s log -2 %s" % (git_exe, commit)

result = exec_cmd(cmd, chromium_src_dir)

if result['out'] != '':

match = re.search(r'refs/heads/master@{#([\d]+)}', result['out'])

assert match != None, 'Failed to find position'

return int(match.groups()[0])

""" Returns the master commit for the specified Chromium commit position. """

cmd = '%s log -1 --grep=refs/heads/master@{#%s} origin/master' % (

git_exe, str(position))

result = exec_cmd(cmd, chromium_src_dir)

if result['out'] != '':

match = re.search(r'^commit ([a-f0-9]+)', result['out'])

assert match != None, 'Failed to find commit'

return match.groups()[0]

""" Returns the list of Chromium versions that contain the specified commit.

cmd = '%s tag --contains %s' % (git_exe, commit)

result = exec_cmd(cmd, chromium_src_dir)

if result['out'] != '':

return [line.strip() for line in result['out'].strip().split('\n')]

""" Returns the compatible Chromium version specified by the CEF checkout. """

compat_path = os.path.join(cef_dir, 'CHROMIUM_BUILD_COMPATIBILITY.txt')

msg("Reading %s" % compat_path)

config = read_config_file(compat_path)

if 'chromium_checkout' in config:

return config['chromium_checkout']

""" Returns the target Chromium version based on a heuristic. """

# The current compatible version from CEF.

compat_version = chromium_compat_version

compat_commit = get_git_hash(chromium_src_dir, compat_version)

if compat_version == compat_commit:

versions = get_chromium_versions(compat_commit)

if len(versions) > 0:

compat_version = 'refs/tags/' + versions[0]

# Closest version may not align with the compat position, so adjust the

# commit to match.

compat_commit = get_git_hash(chromium_src_dir, compat_version)

compat_position = get_chromium_master_position(compat_commit)

compat_date = get_git_date(chromium_src_dir, compat_commit)

# The most recent channel version from the Chromium website.

channel_version = 'refs/tags/' + get_chromium_channel_version(os, channel)

channel_commit = get_chromium_channel_commit(os, channel)

channel_position = get_chromium_master_position(channel_commit)

channel_date = get_git_date(chromium_src_dir, channel_commit)

if compat_position >= channel_position:

# Already compatible with the channel version or newer.

target_version = compat_version

target_commit = compat_commit

target_position = compat_position

target_date = compat_date

elif target_distance <= 0 or compat_position + target_distance >= channel_position:

# Channel version is within the target distance.

target_version = channel_version

target_commit = channel_commit

target_position = channel_position

target_date = channel_date

else:

# Find an intermediary version that's within the target distance.

target_position = compat_position + target_distance

target_commit = get_chromium_master_commit(target_position)

versions = get_chromium_versions(target_commit)

if len(versions) > 0:

target_version = 'refs/tags/' + versions[0]

# Closest version may not align with the target position, so adjust the

# commit and position to match.

target_commit = get_git_hash(chromium_src_dir, target_version)

target_position = get_chromium_master_position(target_commit)

else:

target_version = target_commit

target_date = get_git_date(chromium_src_dir, target_commit)

msg("")

msg("Computed Chromium update for %s %s at distance %d" % (os, channel,

target_distance))

msg("Compat: %s %s %s (#%d)" % (compat_date, compat_version, compat_commit,

compat_position))

msg("Target: %s %s %s (#%d)" % (target_date, target_version, target_commit,

target_position))

msg("Channel: %s %s %s (#%d)" % (channel_date, channel_version,

channel_commit, channel_position))

msg("")

build_dir = ('Debug' if is_debug else 'Release') + '_'

if use_gn:

# CEF uses a consistent directory naming scheme for GN via

# GetAllPlatformConfigs in tools/gn_args.py.

if options.x64build:

build_dir += 'GN_x64'

elif options.armbuild:

build_dir += 'GN_arm'

else:

build_dir += 'GN_x86'

else:

# GYP outputs both x86 and x64 builds to the same directory on Linux and

# Mac OS X. On Windows it suffixes the directory name for x64 builds.

if platform == 'windows' and options.x64build:

build_dir += 'x64'

update_path = os.path.join(cef_src_dir, 'CHROMIUM_UPDATE.txt')

if not os.path.exists(update_path):

msg("Missing file: %s" % update_path)

return None

msg("Reading %s" % update_path)

""" Evaluate the Chromium checkout for changes. """

config = read_update_file()

if config is None:

msg("Skipping Chromium changes log.")

return

if 'files' in config:

out_file = os.path.join(download_dir, 'chromium_update_changes.diff')

if os.path.exists(out_file):

os.remove(out_file)

old_commit = get_chromium_master_commit(

get_chromium_master_position(chromium_compat_version))

new_commit = get_chromium_master_commit(

get_chromium_master_position(chromium_checkout))

cmd = '%s diff --relative --no-prefix %s..%s -- %s' % (

git_exe, old_commit, new_commit, ' '.join(config['files']))

result = exec_cmd(cmd, chromium_src_dir)

if result['out'] != '':

msg('Writing %s' % out_file)

with open(out_file, 'w') as fp:

""" Evaluate the Chromium checkout for pattern matches. """

config = read_update_file()

if config is None:

msg("Skipping Chromium pattern matching.")

return

if 'patterns' in config:

if output_file is None:

fp = sys.stdout

else:

msg('Writing %s' % output_file)

fp = open(output_file, 'w')

has_output = False

for entry in config['patterns']:

msg("Evaluating pattern: %s" % entry['pattern'])

# Read patterns from a file to avoid formatting problems.

pattern_handle, pattern_file = tempfile.mkstemp()

os.write(pattern_handle, entry['pattern'])

os.close(pattern_handle)

cmd = '%s grep -n -f %s' % (git_exe, pattern_file)

result = exec_cmd(cmd, chromium_src_dir)

os.remove(pattern_file)

if result['out'] != '':

write_msg = True

re_exclude = re.compile(

entry['exclude_matches']) if 'exclude_matches' in entry else None

for line in result['out'].split('\n'):

line = line.strip()

if len(line) == 0:

continue

skip = not re_exclude is None and re_exclude.match(line) != None

if not skip:

if write_msg:

if has_output:

fp.write('\n')

fp.write('!!!! WARNING: FOUND PATTERN: %s\n' % entry['pattern'])

if 'message' in entry:

fp.write(entry['message'] + '\n')

fp.write('\n')

write_msg = False

fp.write(line + '\n')

has_output = True

if not output_file is None:

if has_output:

msg('ERROR Matches found. See %s for output.' % out_file)

else:

fp.write('Good news! No matches.\n')

fp.close()

if has_output:

# Don't continue when we know the build will be wrong.