| #!/usr/bin/env vpython |
| # Copyright 2017 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Tool to move Blink source from third_party/WebKit to third_party/blink. |
| |
| See https://docs.google.com/document/d/1l3aPv1Wx__SpRkdOhvJz8ciEGigNT3wFKv78XiuW0Tw/edit?usp=sharing#heading=h.o225wrxp242h |
| for the details. |
| """ |
| |
| import argparse |
| import logging |
| import os |
| import platform |
| import re |
| import sys |
| from functools import partial |
| |
| sys.path.append(os.path.join(os.path.dirname(__file__), |
| '..', 'renderer', 'build', 'scripts')) |
| from blinkbuild.name_style_converter import NameStyleConverter |
| from blinkpy.common.checkout.git import Git |
| from blinkpy.common.path_finder import get_chromium_src_dir |
| from blinkpy.common.path_finder import get_blink_tools_dir |
| from blinkpy.common.system.executive import Executive |
| from blinkpy.common.system.executive import ScriptError |
| from blinkpy.common.system.filesystem import FileSystem |
| from blinkpy.common.system.platform_info import PlatformInfo |
| from plan_blink_move import plan_blink_move |
| from plan_blink_move import relative_dest |
| |
| _log = logging.getLogger('move_blink_source') |
| |
| |
| class FileType(object): |
| NONE = 0 |
| BUILD = 1 |
| BLINK_BUILD = 2 |
| OWNERS = 3 |
| DEPS = 4 |
| MOJOM = 5 |
| TYPEMAP = 6 |
| BLINK_BUILD_PY = 7 |
| LAYOUT_TESTS_WITH_MOJOM = 8 |
| BLINK_DEPS = 9 |
| |
| @staticmethod |
| def detect(path): |
| slash_dir, basename = os.path.split(path) |
| slash_dir = slash_dir.replace(os.path.sep, '/') |
| if basename == 'DEPS': |
| if 'third_party/WebKit' in path: |
| return FileType.BLINK_DEPS |
| return FileType.DEPS |
| if basename == 'OWNERS': |
| return FileType.OWNERS |
| if basename.endswith('.mojom'): |
| return FileType.MOJOM |
| if basename.endswith('.typemap'): |
| return FileType.TYPEMAP |
| if basename.endswith('.py') and 'third_party/WebKit/Source/build' in slash_dir: |
| return FileType.BLINK_BUILD_PY |
| if basename.endswith(('.gn', '.gni')): |
| if 'third_party/WebKit' in path or 'third_party/blink' in slash_dir: |
| return FileType.BLINK_BUILD |
| if 'third_party' in slash_dir: |
| return FileType.NONE |
| return FileType.BUILD |
| if basename.endswith('.html') and re.search( |
| r'third_party/WebKit/LayoutTests/(' |
| r'fast/dom/shadow|' |
| r'fast/forms/color|' |
| r'geolocation-api|' |
| r'http/tests/budget|' |
| r'http/tests/credentialmanager|' |
| r'http/tests/security/powerfulFeatureRestrictions|' |
| r'installedapp|' |
| r'media/mediasession|' |
| r'payments|' |
| r'presentation|' |
| r'reporting-observer|' |
| r'webshare)', slash_dir): |
| return FileType.LAYOUT_TESTS_WITH_MOJOM |
| return FileType.NONE |
| |
| |
| class MoveBlinkSource(object): |
| |
| def __init__(self, fs, options, repo_root): |
| self._fs = fs |
| self._platform = PlatformInfo(sys, platform, fs, Executive()) |
| self._options = options |
| _log.debug(options) |
| self._repo_root = repo_root |
| |
| # The following fields are initialized in _create_basename_maps. |
| self._basename_map = None |
| self._basename_re_list = None |
| self._idl_generated_impl_headers = None |
| # _checked_in_header_re_list is used to distinguish checked-in |
| # header files and generated header files. |
| self._checked_in_header_re_list = None |
| |
| self._updated_files = [] |
| |
| def update(self, apply_only=None): |
| """Updates contents of files affected by Blink source move. |
| |
| Args: |
| apply_only: If it's None, updates all affected files. Otherwise, |
| it should be a set of file paths and this function updates |
| only the files in |apply_only|. |
| """ |
| _log.info('Planning renaming ...') |
| file_pairs = plan_blink_move(self._fs, []) |
| |
| self._create_basename_maps(file_pairs) |
| dirs = self._update_file_content(apply_only) |
| |
| # Updates #includes in files in directories with updated DEPS + |
| # third_party/WebKit/{Source,common,public}. |
| self._append_unless_upper_dir_exists(dirs, self._fs.join(self._repo_root, 'third_party', 'WebKit', 'Source')) |
| self._append_unless_upper_dir_exists(dirs, self._fs.join(self._repo_root, 'third_party', 'WebKit', 'common')) |
| self._append_unless_upper_dir_exists(dirs, self._fs.join(self._repo_root, 'third_party', 'WebKit', 'public')) |
| self._append_unless_upper_dir_exists(dirs, self._fs.join(self._repo_root, 'mojo', 'public', 'tools', |
| 'bindings', 'generators', 'cpp_templates')) |
| self._update_cpp_includes_in_directories(dirs, apply_only) |
| |
| # Content update for individual files. |
| # The following is a list of tuples. |
| # Tuple: (<file path relative to repo root>, [replacement commands]) |
| # Command: a callable object, or |
| # a tuple of (<original string>, <new string>). |
| file_replacement_list = [ |
| ('DEPS', |
| [('src/third_party/WebKit/Source/devtools', |
| 'src/third_party/blink/renderer/devtools')]), |
| ('WATCHLISTS', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer'), |
| ('third_party/WebKit/public', 'third_party/blink/public')]), |
| ('build/check_gn_headers_whitelist.txt', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer'), |
| ('third_party/WebKit/public', 'third_party/blink/public'), |
| self._update_basename]), |
| ('chrome/browser/resources/chromeos/chromevox/tools/jsbundler.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('testing/buildbot/gn_isolate_map.pyl', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('third_party/WebKit/Source/BUILD.gn', |
| [('$root_gen_dir/third_party/WebKit', |
| '$root_gen_dir/third_party/blink')]), |
| ('third_party/WebKit/Source/config.gni', |
| [('snake_case_source_files = false', |
| 'snake_case_source_files = true')]), |
| ('third_party/WebKit/Source/core/css/CSSProperties.json5', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/css/ComputedStyleExtraFields.json5', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/css/ComputedStyleFieldAliases.json5', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/html/parser/create-html-entity-table', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/inspector/inspector_protocol_config.json', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/probe/CoreProbes.json5', |
| [self._update_basename]), |
| ('third_party/WebKit/Source/core/testing/InternalSettings.h', |
| [('InternalSettingsGenerated.h', 'internal_settings_generated.h')]), |
| ('third_party/WebKit/Source/core/testing/Internals.cpp', |
| [('InternalRuntimeFlags.h', 'internal_runtime_flags.h')]), |
| ('third_party/WebKit/Source/platform/probe/PlatformProbes.json5', |
| [self._update_basename]), |
| ('third_party/WebKit/Tools/Scripts/audit-non-blink-usage.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer'), |
| ('ls-files third_party/WebKit', 'ls-files third_party/blink')]), |
| ('third_party/WebKit/Tools/Scripts/webkitpy/style/checker.py', |
| [('Source/', 'renderer/')]), |
| ('third_party/WebKit/public/BUILD.gn', |
| [('$root_gen_dir/third_party/WebKit', |
| '$root_gen_dir/third_party/blink')]), |
| ('third_party/WebKit/public/blink_resources.grd', |
| [('../Source/', '../renderer/')]), |
| ('third_party/blink/tools/compile_devtools_frontend.py', |
| [('\'WebKit\', \'Source\'', '\'blink\', \'renderer\'')]), |
| ('tools/android/eclipse/.classpath', |
| [('third_party/WebKit/public', 'third_party/blink/public')]), |
| ('tools/android/loading/cloud/backend/deploy.sh', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/android/loading/emulation_unittest.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/android/loading/options.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/android/loading/request_track.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/cfi/blacklist.txt', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/gritsettings/resource_ids', |
| [('third_party/WebKit/public', 'third_party/blink/public'), |
| ('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/include_tracer.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/metrics/actions/extract_actions.py', |
| [('third_party/WebKit/Source', 'third_party/blink/renderer')]), |
| ('tools/metrics/histograms/update_editor_commands.py', |
| [('third_party/WebKit/Source/core/editing/EditorCommand.cpp', |
| 'third_party/blink/renderer/core/editing/editor_command.cc')]), |
| ('tools/metrics/histograms/update_use_counter_css.py', |
| [('third_party/WebKit/Source/core/frame/UseCounter.cpp', |
| 'third_party/blink/renderer/core/frame/use_counter.cc')]), |
| ('tools/metrics/histograms/update_use_counter_feature_enum.py', |
| [('third_party/WebKit/public', 'third_party/blink/public')]), |
| ] |
| for file_path, replacement_list in file_replacement_list: |
| if not apply_only or file_path in apply_only: |
| self._update_single_file_content(file_path, replacement_list, should_write=self._options.run) |
| |
| if self._options.run: |
| _log.info('Formatting updated %d files ...', len(self._updated_files)) |
| git = self._create_git() |
| # |git cl format| can't handle too many files at once. |
| while len(self._updated_files) > 0: |
| end_index = 100 |
| if end_index > len(self._updated_files): |
| end_index = len(self._updated_files) |
| git.run(['cl', 'format'] + self._updated_files[:end_index]) |
| self._updated_files = self._updated_files[end_index:] |
| |
| if not apply_only: |
| _log.info('Make a local commit ...') |
| git.commit_locally_with_message("""The Great Blink mv for source files, part 1. |
| |
| Update file contents without moving files. |
| |
| NOAUTOREVERT=true |
| NOPRESUBMIT=true |
| NOTREECHECKS=true |
| Bug: 768828 |
| """) |
| |
| def move(self, apply_only=None): |
| """Move Blink source files. |
| |
| Args: |
| apply_only: If it's None, move all affected files. Otherwise, |
| it should be a set of file paths and this function moves |
| only the files in |apply_only|. |
| """ |
| _log.info('Planning renaming ...') |
| file_pairs = plan_blink_move(self._fs, []) |
| |
| if apply_only: |
| file_pairs = [(src, dest) for (src, dest) in file_pairs |
| if 'third_party/WebKit/' + src.replace('\\', '/') in apply_only] |
| _log.info('Will move %d files', len(file_pairs)) |
| |
| git = self._create_git() |
| files_set = self._get_checked_in_files(git) |
| for i, (src, dest) in enumerate(file_pairs): |
| src_from_repo = self._fs.join('third_party', 'WebKit', src) |
| if src_from_repo.replace('\\', '/') not in files_set: |
| _log.info('%s is not in the repository', src) |
| continue |
| dest_from_repo = self._fs.join('third_party', 'blink', dest) |
| self._fs.maybe_make_directory(self._repo_root, 'third_party', 'blink', self._fs.dirname(dest)) |
| if self._options.run_git: |
| git.move(src_from_repo, dest_from_repo) |
| _log.info('[%d/%d] Git moved %s', i + 1, len(file_pairs), src) |
| else: |
| self._fs.move(self._fs.join(self._repo_root, src_from_repo), |
| self._fs.join(self._repo_root, dest_from_repo)) |
| _log.info('[%d/%d] Moved %s', i + 1, len(file_pairs), src) |
| if apply_only: |
| return |
| |
| self._update_single_file_content( |
| 'build/get_landmines.py', |
| [('\ndef main', ' print \'The Great Blink mv for source files (crbug.com/768828)\'\n\ndef main')]) |
| |
| _log.info('Run run_bindings_tests.py ...') |
| Executive().run_command(['python', |
| self._fs.join(get_blink_tools_dir(), 'run_bindings_tests.py'), |
| '--reset-results'], |
| cwd=self._repo_root) |
| |
| if self._options.run_git: |
| _log.info('Make a local commit ...') |
| git.commit_locally_with_message("""The Great Blink mv for source files, part 2. |
| |
| Move and rename files. |
| |
| NOAUTOREVERT=true |
| NOPRESUBMIT=true |
| NOTREECHECKS=true |
| Bug: 768828 |
| """) |
| |
| def fix_branch(self): |
| git = self._create_git() |
| status = self._get_local_change_status(git) |
| if len(status) == 0: |
| _log.info('No local changes.') |
| return |
| modified_files = {f for (s, f) in status if s != 'D'} |
| deleted_files = {f for (s, f) in status if s == 'D'} |
| |
| self.update(apply_only=modified_files) |
| self.move(apply_only=modified_files) |
| try: |
| git.commit_locally_with_message('This commit should be squashed.') |
| except ScriptError: |
| _log.info('move_blink_source.py modified nothing.') |
| |
| # TODO(tkent): Show a message about deleted_files. |
| |
| def _get_local_change_status(self, git): |
| """Returns a list of tuples representing local change summary. |
| |
| Each tuple contains two strings. The first one is file change status |
| such as "M", "D". See --diff-filter section of git-diff manual page. |
| The second one is file name relative to the repository top. |
| """ |
| |
| base_commit = git.run(['show-branch', '--merge-base', 'master', 'HEAD']).strip() |
| # Note that file names in the following command result are always |
| # slash-separated, even on Windows. |
| status_lines = git.run(['diff', '--name-status', '--no-renames', base_commit]).split('\n') |
| status_tuple_list = [] |
| for l in status_lines: |
| items = l.split('\t') |
| if len(items) == 2: |
| status_tuple_list.append(tuple(items)) |
| elif len(l) > 0: |
| _log.warning('Unrecognized diff output: "%s"', l) |
| return status_tuple_list |
| |
| def _get_checked_in_files(self, git): |
| files_text = git.run(['ls-files', |
| 'third_party/WebKit/Source', |
| 'third_party/WebKit/common', |
| 'third_party/WebKit/public']) |
| return set(files_text.split('\n')) |
| |
| def _create_basename_maps(self, file_pairs): |
| basename_map = {} |
| basenames = [] |
| idl_headers = set() |
| headers = [] |
| for source, dest in file_pairs: |
| _, source_base = self._fs.split(source) |
| _, dest_base = self._fs.split(dest) |
| # OriginTrialFeaturesForCore.h in bindings/tests/results/modules/ |
| # confuses generated/checked-in detection in _replace_include_path(). |
| if 'bindings/tests' in source.replace('\\', '/'): |
| continue |
| if source_base.endswith('.h'): |
| headers.append(re.escape(source_base)) |
| if source_base == dest_base: |
| continue |
| basename_map[source_base] = dest_base |
| basenames.append(re.escape(source_base)) |
| # IDL sometimes generates implementation files as well as |
| # binding files. We'd like to update #includes for such files. |
| if source_base.endswith('.idl'): |
| source_header = source_base.replace('.idl', '.h') |
| basename_map[source_header] = dest_base.replace('.idl', '.h') |
| basenames.append(re.escape(source_header)) |
| idl_headers.add(source_header) |
| elif source_base.endswith('.proto'): |
| source_header = source_base.replace('.proto', '.pb.h') |
| basename_map[source_header] = dest_base.replace('.proto', '.pb.h') |
| basenames.append(re.escape(source_header)) |
| _log.debug('Rename %d files for snake_case', len(basename_map)) |
| self._basename_map = basename_map |
| self._idl_generated_impl_headers = idl_headers |
| |
| self._basename_re_list = [] |
| self._checked_in_header_re_list = [] |
| # Split file names into some chunks to avoid "Regular expression |
| # code size limit exceeded" on Windows |
| CHUNK_SIZE = 700 |
| # Generated inspector/protocol/* contains a lot of names duplicated with |
| # checked-in core files. We don't want to rename them, and don't want to |
| # replace them in BUILD.gn and #include accidentally. |
| RE_PREFIX = r'(?<!inspector/protocol/)' |
| |
| while len(basenames) > 0: |
| end_index = min(CHUNK_SIZE, len(basenames)) |
| self._basename_re_list.append(re.compile(RE_PREFIX + r'\b(' + '|'.join(basenames[0:end_index]) + ')(?=["\']|$)')) |
| basenames = basenames[end_index:] |
| |
| while len(headers) > 0: |
| end_index = min(CHUNK_SIZE, len(headers)) |
| self._checked_in_header_re_list.append(re.compile(RE_PREFIX + r'\b(' + '|'.join(headers[0:end_index]) + ')$')) |
| headers = headers[end_index:] |
| |
| def _shorten_path(self, path): |
| if path.startswith(self._repo_root): |
| return path[len(self._repo_root) + 1:] |
| return path |
| |
| @staticmethod |
| def _filter_file(fs, dirname, basename): |
| return FileType.detect(fs.join(dirname, basename)) != FileType.NONE |
| |
| def _update_build(self, content): |
| content = content.replace('//third_party/WebKit/Source', '//third_party/blink/renderer') |
| content = content.replace('//third_party/WebKit/common', '//third_party/blink/common') |
| content = content.replace('//third_party/WebKit/public', '//third_party/blink/public') |
| # export_header_blink exists outside of Blink too. |
| content = content.replace('export_header_blink = "third_party/WebKit/public/platform/WebCommon.h"', |
| 'export_header_blink = "third_party/blink/public/platform/web_common.h"') |
| content = content.replace('$root_gen_dir/blink/public', '$root_gen_dir/third_party/blink/public') |
| content = content.replace('$root_gen_dir/blink', '$root_gen_dir/third_party/blink/renderer') |
| return content |
| |
| def _update_blink_build(self, content): |
| content = self._update_build(content) |
| |
| # Update visibility=[...] |
| content = content.replace('//third_party/WebKit/*', '//third_party/blink/*') |
| content = content.replace('//third_party/WebKit/Source/*', '//third_party/blink/renderer/*') |
| content = content.replace('//third_party/WebKit/public/*', '//third_party/blink/public/*') |
| |
| # Update mojom variables |
| content = content.replace('export_header = "third_party/WebKit/common', |
| 'export_header = "third_party/blink/common') |
| content = content.replace('export_header_blink = "third_party/WebKit/Source', |
| 'export_header_blink = "third_party/blink/renderer') |
| |
| # Update buildflag_header() rules |
| content = content.replace('header_dir = "blink/', |
| 'header_dir = "third_party/blink/renderer/') |
| |
| return self._update_basename(content) |
| |
| def _update_owners(self, content): |
| content = content.replace('//third_party/WebKit/Source', '//third_party/blink/renderer') |
| content = content.replace('//third_party/WebKit/common', '//third_party/blink/common') |
| content = content.replace('//third_party/WebKit/public', '//third_party/blink/public') |
| return content |
| |
| def _update_deps(self, content): |
| original_content = content |
| content = content.replace('third_party/WebKit/Source', 'third_party/blink/renderer') |
| content = content.replace('third_party/WebKit/common', 'third_party/blink/common') |
| content = content.replace('third_party/WebKit/public', 'third_party/blink/public') |
| content = content.replace('third_party/WebKit', 'third_party/blink') |
| if original_content == content: |
| return content |
| return self._update_basename(content) |
| |
| def _update_blink_deps(self, content): |
| original_content = content |
| content = re.sub('(?<=[-+!])public', 'third_party/blink/public', content) |
| content = re.sub('(?<=[-+!])(bindings|controller|core|modules|platform)', |
| 'third_party/blink/renderer/\\1', content) |
| content = content.replace('third_party/WebKit', 'third_party/blink') |
| if original_content == content: |
| return content |
| return self._update_basename(content) |
| |
| def _update_mojom(self, content): |
| content = content.replace('third_party/WebKit/public', 'third_party/blink/public') |
| content = content.replace('third_party/WebKit/common', 'third_party/blink/common') |
| return content |
| |
| def _update_typemap(self, content): |
| content = content.replace('//third_party/WebKit/Source', '//third_party/blink/renderer') |
| content = content.replace('//third_party/WebKit/common', '//third_party/blink/common') |
| content = content.replace('//third_party/WebKit/public', '//third_party/blink/public') |
| return self._update_basename(content) |
| |
| def _update_blink_build_py(self, content): |
| # We don't prepend 'third_party/blink/renderer/' to matched basenames |
| # because it won't affect build and manual update after the great mv is |
| # enough. |
| return self._update_basename(content) |
| |
| def _update_layout_tests(self, content): |
| return content.replace('file:///gen/third_party/WebKit/public/', |
| 'file:///gen/third_party/blink/public/') |
| |
| def _update_basename(self, content): |
| for regex in self._basename_re_list: |
| content = regex.sub(lambda match: self._basename_map[match.group(1)], content) |
| return content |
| |
| @staticmethod |
| def _append_unless_upper_dir_exists(dirs, new_dir): |
| for i in range(0, len(dirs)): |
| if new_dir.startswith(dirs[i]): |
| return |
| if dirs[i].startswith(new_dir): |
| dirs[i] = new_dir |
| return |
| dirs.append(new_dir) |
| |
| def _update_file_content(self, apply_only): |
| _log.info('Find *.gn, *.mojom, *.py, *.typemap, DEPS, and OWNERS ...') |
| files = self._fs.files_under( |
| self._repo_root, dirs_to_skip=['.git', 'out'], file_filter=self._filter_file) |
| _log.info('Scan contents of %d files ...', len(files)) |
| updated_deps_dirs = [] |
| for file_path in files: |
| file_type = FileType.detect(file_path) |
| original_content = self._fs.read_text_file(file_path) |
| content = original_content |
| if file_type == FileType.BUILD: |
| content = self._update_build(content) |
| elif file_type == FileType.BLINK_BUILD: |
| content = self._update_blink_build(content) |
| elif file_type == FileType.OWNERS: |
| content = self._update_owners(content) |
| elif file_type == FileType.DEPS: |
| if self._fs.dirname(file_path) == self._repo_root: |
| _log.debug("Skip //DEPS") |
| continue |
| content = self._update_deps(content) |
| elif file_type == FileType.BLINK_DEPS: |
| content = self._update_blink_deps(content) |
| elif file_type == FileType.MOJOM: |
| content = self._update_mojom(content) |
| elif file_type == FileType.TYPEMAP: |
| content = self._update_typemap(content) |
| elif file_type == FileType.BLINK_BUILD_PY: |
| content = self._update_blink_build_py(content) |
| elif file_type == FileType.LAYOUT_TESTS_WITH_MOJOM: |
| content = self._update_layout_tests(content) |
| |
| if original_content == content: |
| continue |
| if self._options.run and (not apply_only or file_path.replace('\\', '/') in apply_only): |
| self._fs.write_text_file(file_path, content) |
| self._updated_files.append(file_path) |
| _log.info('Updated %s', self._shorten_path(file_path)) |
| if file_type == FileType.DEPS: |
| self._append_unless_upper_dir_exists(updated_deps_dirs, self._fs.dirname(file_path)) |
| return updated_deps_dirs |
| |
| def _update_cpp_includes_in_directories(self, dirs, apply_only): |
| for dirname in dirs: |
| _log.info('Processing #include in %s ...', self._shorten_path(dirname)) |
| files = self._fs.files_under( |
| dirname, file_filter=lambda fs, _, basename: basename.endswith( |
| ('.h', '.cc', '.cpp', '.mm', '.cc.tmpl', '.cpp.tmpl', |
| '.h.tmpl', 'xpath_grammar.y', '.gperf'))) |
| for file_path in files: |
| posix_file_path = file_path.replace('\\', '/') |
| if '/third_party/WebKit/Source/bindings/tests/results/' in posix_file_path: |
| continue |
| original_content = self._fs.read_text_file(file_path) |
| |
| content = self._update_cpp_includes(original_content) |
| if file_path.endswith('.h') and '/third_party/WebKit/public/' in posix_file_path: |
| content = self._update_basename_only_includes(content, file_path) |
| if file_path.endswith('.h') and '/third_party/WebKit/' in posix_file_path: |
| content = self._update_include_guard(content, file_path) |
| |
| if original_content == content: |
| continue |
| if self._options.run and (not apply_only or posix_file_path in apply_only): |
| self._fs.write_text_file(file_path, content) |
| self._updated_files.append(file_path) |
| _log.info('Updated %s', self._shorten_path(file_path)) |
| |
| def _replace_include_path(self, match): |
| include_or_import = match.group(1) |
| path = match.group(2) |
| |
| # If |path| starts with 'blink/public/resources', we should prepend |
| # 'third_party/'. |
| # |
| # If |path| starts with 'third_party/WebKit', we should adjust the |
| # directory name for third_party/blink, and replace its basename by |
| # self._basename_map. |
| # |
| # If |path| starts with a Blink-internal directory such as bindings, |
| # core, modules, platform, public, it refers to a checked-in file, or a |
| # generated file. For the former, we should add 'third_party/blink/' and |
| # replace the basename. For the latter, we should update the basename |
| # for a name mapped from an IDL renaming, and should add |
| # 'third_party/blink/'. |
| |
| if path.startswith('blink/public/resources'): |
| path = path.replace('blink/public', 'third_party/blink/public') |
| return '#%s "%s"' % (include_or_import, path) |
| |
| if path.startswith('third_party/WebKit'): |
| path = path.replace('third_party/WebKit/Source', 'third_party/blink/renderer') |
| path = path.replace('third_party/WebKit/common', 'third_party/blink/common') |
| path = path.replace('third_party/WebKit/public', 'third_party/blink/public') |
| path = self._update_basename(path) |
| return '#%s "%s"' % (include_or_import, path) |
| |
| match = None |
| for regex in self._checked_in_header_re_list: |
| match = regex.search(path) |
| if match: |
| break |
| if match: |
| if match.group(1) in self._basename_map: |
| path = path[:match.start(1)] + self._basename_map[match.group(1)] |
| elif 'core/inspector/protocol/' not in path: |
| basename_start = path.rfind('/') + 1 |
| basename = path[basename_start:] |
| if basename in self._idl_generated_impl_headers: |
| path = path[:basename_start] + self._basename_map[basename] |
| elif basename.startswith('V8'): |
| path = path[:basename_start] + NameStyleConverter(basename[:len(basename) - 2]).to_snake_case() + '.h' |
| if path.startswith('public'): |
| path = 'third_party/blink/' + path |
| else: |
| path = 'third_party/blink/renderer/' + path |
| return '#%s "%s"' % (include_or_import, path) |
| |
| def _update_cpp_includes(self, content): |
| pattern = re.compile(r'#(include|import)\s+"((bindings|controller|core|modules|platform|public|' + |
| r'third_party/WebKit/(Source|common|public)|blink/public/resources)/[-_\w/.]+)"') |
| return pattern.sub(self._replace_include_path, content) |
| |
| def _replace_basename_only_include(self, subdir, source_path, match): |
| source_basename = match.group(1) |
| if source_basename in self._basename_map: |
| return '#include "third_party/blink/public/%s/%s"' % (subdir, self._basename_map[source_basename]) |
| _log.warning('Basename-only %s in %s', match.group(0), self._shorten_path(source_path)) |
| return match.group(0) |
| |
| def _update_basename_only_includes(self, content, source_path): |
| if not source_path.endswith('.h') or '/third_party/WebKit/public/' not in source_path.replace('\\', '/'): |
| return |
| # In public/ header files, we should replace |#include "WebFoo.h"| |
| # with |#include "third_party/blink/public/platform-or-web/web_foo.h"| |
| subdir = self._fs.basename(self._fs.dirname(source_path)) |
| # subdir is 'web' or 'platform'. |
| return re.sub(r'#include\s+"(\w+\.h)"', |
| partial(self._replace_basename_only_include, subdir, source_path), content) |
| |
| def _update_include_guard(self, content, source_path): |
| current_guard = re.sub(r'[-.]', '_', self._fs.basename(source_path)) |
| new_path = relative_dest(self._fs, self._fs.relpath( |
| source_path, start=self._fs.join(self._repo_root, 'third_party', 'WebKit'))) |
| new_guard = 'THIRD_PARTY_BLINK_' + re.sub(r'[-\\/.]', '_', new_path.upper()) + '_' |
| content = re.sub(r'#ifndef\s+(WTF_)?' + current_guard, '#ifndef ' + new_guard, content); |
| content = re.sub(r'#define\s+(WTF_)?' + current_guard, '#define ' + new_guard, content); |
| content = re.sub(r'#endif\s+//\s+(WTF_)?' + current_guard, '#endif // ' + new_guard, content); |
| return content |
| |
| def _update_single_file_content(self, file_path, replace_list, should_write=True): |
| full_path = self._fs.join(self._repo_root, file_path) |
| original_content = self._fs.read_text_file(full_path) |
| content = original_content |
| for command in replace_list: |
| if isinstance(command, tuple): |
| src, dest = command |
| content = content.replace(src, dest) |
| elif callable(command): |
| content = command(content) |
| else: |
| raise TypeError('A tuple or a function is expected.') |
| if content != original_content: |
| if should_write: |
| self._fs.write_text_file(full_path, content) |
| self._updated_files.append(full_path) |
| _log.info('Updated %s', file_path) |
| else: |
| _log.warning('%s does not contain specified source strings.', file_path) |
| |
| def _create_git(self): |
| return Git(cwd=self._repo_root, filesystem=self._fs, platform=self._platform) |
| |
| |
| def main(): |
| logging.basicConfig(level=logging.INFO, |
| format='[%(asctime)s %(levelname)s %(name)s] %(message)s', |
| datefmt='%H:%M:%S') |
| parser = argparse.ArgumentParser(description='Blink source mover') |
| sub_parsers = parser.add_subparsers() |
| |
| update_parser = sub_parsers.add_parser('update') |
| update_parser.set_defaults(command='update') |
| update_parser.add_argument('--run', dest='run', action='store_true', |
| help='Update file contents') |
| |
| move_parser = sub_parsers.add_parser('move') |
| move_parser.set_defaults(command='move') |
| move_parser.add_argument('--git', dest='run_git', action='store_true', |
| help='Run |git mv| command instead of |mv|.') |
| |
| fixbranch_parser = sub_parsers.add_parser('fixbranch') |
| fixbranch_parser.set_defaults(command='fixbranch', run=True, run_git=True) |
| |
| options = parser.parse_args() |
| mover = MoveBlinkSource(FileSystem(), options, get_chromium_src_dir()) |
| if options.command == 'update': |
| mover.update() |
| elif options.command == 'move': |
| mover.move() |
| elif options.command == 'fixbranch': |
| mover.fix_branch() |
| |
| |
| if __name__ == '__main__': |
| main() |
