PRESUBMIT Namespace Reference

Classes
class	_WarningsAsErrors
class	CodeReview

Functions
	load_source (modname, filename)
	runSmokeTest (input_api, output_api)
	CheckChangeOnCommit (input_api, output_api)
	CheckChangeOnUpload (input_api, output_api)
	EnsurePubspecAndChangelogAltered (input_api, package_name)
	CheckChange (input_api, output_api)
	CheckNodeTextExpectationsCollectorUpdatingIsDisabled (input_api, output_api)
	is_cpp_file (path)
	is_dart_file (path)
	get_old_contents (input_api, path)
	files_to_check_for_format (input_api, extension, exclude_folders)
	_CheckFormat (input_api, identification, extension, windows, Callable[[str, list, str], bool] hasFormatErrors, exclude_folders)
	_CheckDartFormat (input_api, output_api)
	_CheckStatusFiles (input_api, output_api)
	_CheckValidHostsInDEPS (input_api, output_api)
	_CheckLayering (input_api, output_api)
	_CheckClangTidy (input_api, output_api)
	_CheckClangFormat (input_api, output_api)
	_CheckAnalyzerFiles (input_api, output_api)
	_CheckTestMatrixValid (input_api, output_api)
	_CheckCopyrightYear (input_api, output_api)
	_CheckNoNewObservatoryServiceTests (input_api, output_api)
	_CommonChecks (input_api, output_api)
	CheckMemcpy (filename)
	RunLint (input_api, output_api)
	CheckGn (input_api, output_api)
	CheckFormatted (input_api, output_api)
	_CheckChangeHasEol (input_api, output_api, source_file_filter=None)
	_JsonChecks (input_api, output_api)
	_IfDefChecks (input_api, output_api)
	_CopyrightChecks (input_api, output_api, source_file_filter=None)
	_InfraTests (input_api, output_api)
	_CheckGNFormatted (input_api, output_api)
	_CheckGitConflictMarkers (input_api, output_api)
	_CheckIncludesFormatted (input_api, output_api)
	_RegenerateAllExamplesCPP (input_api, output_api)
	_CheckExamplesForPrivateAPIs (input_api, output_api)
	_CheckGeneratedBazelBUILDFiles (input_api, output_api)
	_CheckBazelBUILDFiles (input_api, output_api)
	_CheckPublicBzl (input_api, output_api)
	_RunCommandAndCheckGitDiff (output_api, command)
	_CheckGNIGenerated (input_api, output_api)
	_CheckBuildifier (input_api, output_api)
	_CheckBannedAPIs (input_api, output_api)
	_CheckDEPS (input_api, output_api)
	_CheckReleaseNotesForPublicAPI (input_api, output_api)
	_CheckTopReleaseNotesChanged (input_api, output_api)
	PostUploadHook (gerrit, change, output_api)

Variables
bool	USE_PYTHON3 = True
str	PRESUBMIT_VERSION = '2.0.0'
str	RELEASE_NOTES_DIR = 'relnotes'
str	RELEASE_NOTES_FILE_NAME = 'RELEASE_NOTES.md'
str	RELEASE_NOTES_README = '//relnotes/README.md'
str	GOLD_TRYBOT_URL = 'https://gold.skia.org/search?issue='
list	SERVICE_ACCOUNT_SUFFIX

Detailed Description

CFE et al presubmit python script.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

_macros package presubmit python script.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

Analyzer specific presubmit script.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

Top-level presubmit script for Dart.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

sdk/lib specific presubmit script.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

Top-level presubmit script for Skia.

See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
for more details about the presubmit API built into gcl.

Function Documentation

_CheckAnalyzerFiles()

PRESUBMIT._CheckAnalyzerFiles (   input_api,   output_api  )

protected

Run analyzer checks on source files.

Definition at line 383 of file PRESUBMIT.py.

def _CheckAnalyzerFiles(input_api, output_api):
    """Run analyzer checks on source files."""
 
    # Verify the "error fix status" file.
    code_files = [
        "pkg/analyzer/lib/src/error/error_code_values.g.dart",
        "pkg/linter/lib/src/rules.dart",
    ]
 
    if any(f.LocalPath() in code_files for f in input_api.AffectedFiles()):
        args = [
            "tools/sdks/dart-sdk/bin/dart",
            "pkg/analysis_server/tool/presubmit/verify_error_fix_status.dart",
        ]
        stdout = input_api.subprocess.check_output(args).strip()
        if not stdout:
            return []
 
        return [
            output_api.PresubmitError(
                "The verify_error_fix_status Analyzer tool revealed issues:",
                long_text=stdout)
        ]
 
    # Verify the linter's `example/all.yaml` file.
    if any(f.LocalPath().startswith('pkg/linter/lib/src/rules')
           for f in input_api.AffectedFiles()):
        args = [
            "tools/sdks/dart-sdk/bin/dart",
            "pkg/linter/tool/checks/check_all_yaml.dart",
        ]
        stdout = input_api.subprocess.check_output(args).strip()
        if not stdout:
            return []
 
        return [
            output_api.PresubmitError(
                "The check_all_yaml linter tool revealed issues:",
                long_text=stdout)
        ]
 
    # TODO(srawlins): Check more:
    # * "verify_sorted" for individual modified (not deleted) files in
    #   Analyzer-team-owned directories.
    # * "verify_tests" for individual modified (not deleted) test files in
    #   Analyzer-team-owned directories.
    # * Verify that `messages/generate.dart` does not produce different
    #   content, when `pkg/analyzer/messages.yaml` is modified.
    # * Verify that `diagnostics/generate.dart` does not produce different
    #   content, when `pkg/analyzer/messages.yaml` is modified.
    # * Verify that `machine.json` is not outdated, when any
    #   `pkg/linter/lib/src/rules` file is modified.
    # * Maybe "verify_no_solo" for individual modified (not deleted test files
    #   in Analyzer-team-owned directories.
 
    # No files are relevant.
    return []
 
 

_CheckBannedAPIs()

PRESUBMIT._CheckBannedAPIs (   input_api,   output_api  )

protected

Check source code for functions and packages that should not be used.

Definition at line 464 of file PRESUBMIT.py.

def _CheckBannedAPIs(input_api, output_api):
  """Check source code for functions and packages that should not be used."""
 
  # A list of tuples of a regex to match an API and a suggested replacement for
  # that API. There is an optional third parameter for files which *can* use this
  # API without warning.
  banned_replacements = [
    (r'std::stof\‍(', 'std::strtof(), which does not throw'),
    (r'std::stod\‍(', 'std::strtod(), which does not throw'),
    (r'std::stold\‍(', 'std::strtold(), which does not throw'),
  ]
 
  # These defines are either there or not, and using them with just an #if is a
  # subtle, frustrating bug.
  existence_defines = ['SK_GANESH', 'SK_GRAPHITE', 'SK_GL', 'SK_VULKAN', 'SK_DAWN', 'SK_METAL',
                       'SK_DIRECT3D', 'SK_DEBUG', 'GR_TEST_UTILS', 'GRAPHITE_TEST_UTILS']
  for d in existence_defines:
    banned_replacements.append(('#if {}'.format(d),
                                '#if defined({})'.format(d)))
  compiled_replacements = []
  for rep in banned_replacements:
    exceptions = []
    if len(rep) == 3:
      (re, replacement, exceptions) = rep
    else:
      (re, replacement) = rep
 
    compiled_re = input_api.re.compile(re)
    compiled_exceptions = [input_api.re.compile(exc) for exc in exceptions]
    compiled_replacements.append(
        (compiled_re, replacement, compiled_exceptions))
 
  errors = []
  file_filter = lambda x: (x.LocalPath().endswith('.h') or
                           x.LocalPath().endswith('.cpp') or
                           x.LocalPath().endswith('.cc') or
                           x.LocalPath().endswith('.m') or
                           x.LocalPath().endswith('.mm'))
  for affected_file in input_api.AffectedSourceFiles(file_filter):
    affected_filepath = affected_file.LocalPath()
    for (line_num, line) in affected_file.ChangedContents():
      for (re, replacement, exceptions) in compiled_replacements:
        match = re.search(line)
        if match:
          for exc in exceptions:
            if exc.search(affected_filepath):
              break
          else:
            errors.append('%s:%s: Instead of %s, please use %s.' % (
                affected_filepath, line_num, match.group(), replacement))
 
  if errors:
    return [output_api.PresubmitError('\n'.join(errors))]
 
  return []
 
 

_CheckBazelBUILDFiles()

PRESUBMIT._CheckBazelBUILDFiles (   input_api,   output_api  )

protected

Makes sure our BUILD.bazel files are compatible with G3.

Definition at line 287 of file PRESUBMIT.py.

def _CheckBazelBUILDFiles(input_api, output_api):
  """Makes sure our BUILD.bazel files are compatible with G3."""
  results = []
  for affected_file in input_api.AffectedFiles(include_deletes=False):
    affected_file_path = affected_file.LocalPath()
    is_bazel = affected_file_path.endswith('BUILD.bazel')
    # This list lines up with the one in autoroller_lib.py (see G3).
    excluded_paths = ["infra/", "bazel/rbe/", "bazel/external/", "bazel/common_config_settings/",
                      "modules/canvaskit/go/", "experimental/", "bazel/platform", "third_party/",
                      "tests/", "resources/", "bazel/deps_parser/", "bazel/exporter_tool/",
                      "tools/gpu/gl/interface/", "bazel/utils/", "include/config/",
                      "bench/", "example/external_client/"]
    is_excluded = any(affected_file_path.startswith(n) for n in excluded_paths)
    if is_bazel and not is_excluded:
      with open(affected_file_path, 'r') as file:
        contents = file.read()
        if 'exports_files_legacy(' not in contents:
          results.append(output_api.PresubmitError(
            ('%s needs to call exports_files_legacy() to support legacy G3 ' +
             'rules.\nPut this near the top of the file, beneath ' +
             'licenses(["notice"]).') % affected_file_path
          ))
        if 'licenses(["notice"])' not in contents:
          results.append(output_api.PresubmitError(
            ('%s needs to have\nlicenses(["notice"])\nimmediately after ' +
             'the load() calls to comply with G3 policies.') % affected_file_path
          ))
        if 'cc_library(' in contents and '"skia_cc_library"' not in contents:
          results.append(output_api.PresubmitError(
            ('%s needs to load skia_cc_library from macros.bzl instead of using the ' +
             'native one. This allows us to build differently for G3.\n' +
             'Add "skia_cc_library" to load("//bazel:macros.bzl", ...)')
            % affected_file_path
          ))
        if 'default_applicable_licenses' not in contents:
          # See https://opensource.google/documentation/reference/thirdparty/new_license_rules
          results.append(output_api.PresubmitError(
            ('%s needs to have\npackage(default_applicable_licenses = ["//:license"])\n'+
             'to comply with G3 policies') % affected_file_path
          ))
  return results
 
 

_CheckBuildifier()

PRESUBMIT._CheckBuildifier (   input_api,   output_api  )

protected

Runs Buildifier and fails on linting errors, or if it produces any diffs.

This check only runs if the affected files include any WORKSPACE, BUILD,
BUILD.bazel or *.bzl files.

Definition at line 417 of file PRESUBMIT.py.

def _CheckBuildifier(input_api, output_api):
  """Runs Buildifier and fails on linting errors, or if it produces any diffs.
 
  This check only runs if the affected files include any WORKSPACE, BUILD,
  BUILD.bazel or *.bzl files.
  """
  files = []
  # Please keep the below exclude patterns in sync with those in the //:buildifier rule definition.
  for affected_file in input_api.AffectedFiles(include_deletes=False):
    affected_file_path = affected_file.LocalPath()
    if affected_file_path.endswith('BUILD.bazel') or affected_file_path.endswith('.bzl'):
      if not affected_file_path.endswith('public.bzl') and \
        not affected_file_path.endswith('go_repositories.bzl') and \
        not "bazel/rbe/gce_linux/" in affected_file_path and \
        not affected_file_path.startswith("third_party/externals/") and \
        not "node_modules/" in affected_file_path:  # Skip generated files.
        files.append(affected_file_path)
  if not files:
    return []
  try:
    subprocess.check_output(
        ['buildifier', '--version'],
        stderr=subprocess.STDOUT)
  except:
    return [output_api.PresubmitNotifyResult(
      'Skipping buildifier check because it is not on PATH. \n' +
      'You can download it from https://github.com/bazelbuild/buildtools/releases')]
 
  return _RunCommandAndCheckGitDiff(
    # One can change --lint=warn to --lint=fix to have things automatically fixed where possible.
    # However, --lint=fix will not cause a presubmit error if there are things that require
    # manual intervention, so we leave --lint=warn on by default.
    #
    # Please keep the below arguments in sync with those in the //:buildifier rule definition.
    output_api, [
      'buildifier',
      '--mode=fix',
      '--lint=warn',
      '--warnings',
      ','.join([
        '-native-android',
        '-native-cc',
        '-native-py',
      ])
    ] + files)
 
 

_CheckChangeHasEol()

PRESUBMIT._CheckChangeHasEol (   input_api,   output_api,   source_file_filter = None  )

protected

Checks that files end with at least one \n (LF).

Definition at line 35 of file PRESUBMIT.py.

def _CheckChangeHasEol(input_api, output_api, source_file_filter=None):
  """Checks that files end with at least one \n (LF)."""
  eof_files = []
  for f in input_api.AffectedSourceFiles(source_file_filter):
    contents = input_api.ReadFile(f, 'rb')
    # Check that the file ends in at least one newline character.
    if len(contents) > 1 and contents[-1:] != '\n':
      eof_files.append(f.LocalPath())
 
  if eof_files:
    return [output_api.PresubmitPromptWarning(
      'These files should end in a newline character:',
      items=eof_files)]
  return []
 
 

_CheckClangFormat()

PRESUBMIT._CheckClangFormat (   input_api,   output_api  )

protected

Run clang-format on VM changes.

Definition at line 332 of file PRESUBMIT.py.

def _CheckClangFormat(input_api, output_api):
    """Run clang-format on VM changes."""
 
    # Only run clang-format on linux x64.
    if platform.system() != 'Linux' or platform.machine() != 'x86_64':
        return []
 
    # Run only for modified .cc or .h files, except for DEPS changes.
    files = []
    is_deps = False
    for f in input_api.AffectedFiles():
        path = f.LocalPath()
        if path == 'DEPS' and any(
                map(lambda content: 'clang' in content[1],
                    f.ChangedContents())):
            is_deps = True
            break
        if is_cpp_file(path) and os.path.isfile(path):
            files.append(path)
 
    if is_deps:
        find_args = [
            'find',
            'runtime/',
            '-iname',
            '*.h',
            '-o',
            '-iname',
            '*.cc',
        ]
        files = subprocess.check_output(find_args, text=True).split()
 
    if not files:
        return []
 
    args = [
        'buildtools/linux-x64/clang/bin/clang-format',
        '--dry-run',
        '--Werror',
    ]
    args.extend(files)
    stdout = input_api.subprocess.check_output(args).strip()
    if not stdout:
        return []
 
    return [
        output_api.PresubmitError('The `clang-format` revealed issues:',
                                  long_text=stdout)
    ]
 
 

_CheckClangTidy()

PRESUBMIT._CheckClangTidy (   input_api,   output_api  )

protected

Run clang-tidy on VM changes.

Definition at line 300 of file PRESUBMIT.py.

def _CheckClangTidy(input_api, output_api):
    """Run clang-tidy on VM changes."""
 
    # Only run clang-tidy on linux x64.
    if platform.system() != 'Linux' or platform.machine() != 'x86_64':
        return []
 
    # Run only for modified .cc or .h files.
    files = []
    for f in input_api.AffectedFiles():
        path = f.LocalPath()
        if is_cpp_file(path) and os.path.isfile(path): files.append(path)
 
    if not files:
        return []
 
    args = [
        'tools/sdks/dart-sdk/bin/dart',
        'runtime/tools/run_clang_tidy.dart',
    ]
    args.extend(files)
    stdout = input_api.subprocess.check_output(args).strip()
    if not stdout:
        return []
 
    return [
        output_api.PresubmitError(
            'The `clang-tidy` linter revealed issues:',
            long_text=stdout)
    ]
 
 

_CheckCopyrightYear()

PRESUBMIT._CheckCopyrightYear (   input_api,   output_api  )

protected

Check copyright year in new files.

Definition at line 472 of file PRESUBMIT.py.

def _CheckCopyrightYear(input_api, output_api):
    """Check copyright year in new files."""
 
    files = []
    year = str(datetime.datetime.now().year)
    for f in input_api.AffectedFiles(include_deletes=False):
        path = f.LocalPath()
        if (is_dart_file(path) or is_cpp_file(path)
           ) and f.Action() == 'A' and os.path.isfile(path):
            with open(path, encoding='utf-8') as f:
                first_line = f.readline()
                if 'Copyright' in first_line and year not in first_line:
                    files.append(path)
 
    if not files:
        return []
 
    return [
        output_api.PresubmitPromptWarning(
            'Copyright year for new files should be ' + year + ':\n' +
            '\n'.join(files))
    ]
 
 

_CheckDartFormat()

PRESUBMIT._CheckDartFormat (   input_api,   output_api  )

protected

Definition at line 106 of file PRESUBMIT.py.

def _CheckDartFormat(input_api, output_api):
    local_root = input_api.change.RepositoryRoot()
    utils = load_source('utils', os.path.join(local_root, 'tools', 'utils.py'))
 
    dart = os.path.join(utils.CheckedInSdkPath(), 'bin', 'dart')
 
    windows = utils.GuessOS() == 'win32'
    if windows:
        dart += '.exe'
 
    if not os.path.isfile(dart):
        print('WARNING: dart not found: %s' % (dart))
        return []
 
    dartFixes = [
        '--fix-named-default-separator',
    ]
 
    def HasFormatErrors(filename: str = None,
                        filenames: list = None,
                        contents: str = None):
        # Don't look for formatting errors in multitests. Since those are very
        # sensitive to whitespace, many cannot be reformatted without breaking
        # them.
        def skip_file(path):
            if path.endswith('_test.dart'):
                with open(path, encoding='utf-8') as f:
                    contents = f.read()
                    if '//#' in contents:
                        return True
            return False
 
        if filename and skip_file(filename):
            return False
 
        args = [
            dart,
            'format',
        ] + dartFixes + [
            '--set-exit-if-changed',
            '--output=none',
            '--summary=none',
        ]
 
        # TODO(https://github.com/dart-lang/sdk/issues/46947): Remove this hack.
        if windows and contents:
            f = tempfile.NamedTemporaryFile(
                encoding='utf-8',
                delete=False,
                mode='w',
                suffix='.dart',
            )
            try:
                f.write(contents)
                f.close()
                args.append(f.name)
                process = subprocess.run(args)
            finally:
                os.unlink(f.name)
        elif contents:
            process = subprocess.run(args, input=contents, text=True)
        elif filenames:
            args += [f for f in filenames if not skip_file(f)]
            process = subprocess.run(args)
        else:
            args.append(filename)
            process = subprocess.run(args)
 
        # Check for exit code 1 explicitly to distinguish it from a syntax error
        # in the file (exit code 65). The repo contains many Dart files that are
        # known to have syntax errors for testing purposes and which can't be
        # parsed and formatted. Don't treat those as errors.
        return process.returncode == 1
 
    unformatted_files = _CheckFormat(input_api, "dart format", ".dart", windows,
                                     HasFormatErrors, [])
 
    if unformatted_files:
        lineSep = " \\\n"
        if windows:
            lineSep = " ^\n"
        return [
            output_api.PresubmitError(
                'File output does not match dart format.\n'
                'Fix these issues with:\n'
                '%s format %s%s%s' % (dart, ' '.join(dartFixes), lineSep,
                                      lineSep.join(unformatted_files)))
        ]
 
    return []
 
 

_CheckDEPS()

PRESUBMIT._CheckDEPS (   input_api,   output_api  )

protected

If DEPS was modified, run the deps_parser to update bazel/deps.bzl

Definition at line 521 of file PRESUBMIT.py.

def _CheckDEPS(input_api, output_api):
  """If DEPS was modified, run the deps_parser to update bazel/deps.bzl"""
  needs_running = False
  for affected_file in input_api.AffectedFiles(include_deletes=False):
    affected_file_path = affected_file.LocalPath()
    if affected_file_path.endswith('DEPS') or affected_file_path.endswith('deps.bzl'):
      needs_running = True
      break
  if not needs_running:
    return []
  try:
    subprocess.check_output(
        ['bazelisk', '--version'],
        stderr=subprocess.STDOUT)
  except:
    return [output_api.PresubmitNotifyResult(
      'Skipping DEPS check because bazelisk is not on PATH. \n' +
      'You can download it from https://github.com/bazelbuild/bazelisk/releases/tag/v1.14.0')]
 
  return _RunCommandAndCheckGitDiff(
    output_api, ['bazelisk', 'run', '//bazel/deps_parser'])
 
 

_CheckExamplesForPrivateAPIs()

PRESUBMIT._CheckExamplesForPrivateAPIs (   input_api,   output_api  )

protected

We only want our checked-in examples (aka fiddles) to show public API.

Definition at line 248 of file PRESUBMIT.py.

def _CheckExamplesForPrivateAPIs(input_api, output_api):
  """We only want our checked-in examples (aka fiddles) to show public API."""
  banned_includes = [
    input_api.re.compile(r'#\s*include\s+("src/.*)'),
    input_api.re.compile(r'#\s*include\s+("include/private/.*)'),
  ]
  file_filter = lambda x: (x.LocalPath().startswith('docs/examples/'))
  errors = []
  for affected_file in input_api.AffectedSourceFiles(file_filter):
    affected_filepath = affected_file.LocalPath()
    for (line_num, line) in affected_file.ChangedContents():
      for re in banned_includes:
        match = re.search(line)
        if match:
          errors.append('%s:%s: Fiddles should not use private/internal API like %s.' % (
                affected_filepath, line_num, match.group(1)))
 
  if errors:
    return [output_api.PresubmitError('\n'.join(errors))]
  return []
 
 

_CheckFormat()

PRESUBMIT._CheckFormat (   input_api,   identification,   extension,   windows, Callable[[str, list, str], bool]  hasFormatErrors,   exclude_folders  )

protected

Definition at line 56 of file PRESUBMIT.py.

                                           bool], exclude_folders):
    files = files_to_check_for_format(input_api, extension, exclude_folders)
    if not files:
        return []
 
    # Check for formatting errors in bulk first. This is orders of magnitude
    # faster than checking file-by-file on large changes with hundreds of files.
    if not hasFormatErrors(filenames=[f.AbsoluteLocalPath() for f in files]):
        return []
 
    print("Formatting errors found, comparing against old versions.")
    unformatted_files = []
    for git_file in files:
        filename = git_file.AbsoluteLocalPath()
        if hasFormatErrors(filename=filename):
            old_version_has_errors = False
            try:
                path = git_file.LocalPath()
                if windows:
                    # Git expects a linux style path.
                    path = path.replace(os.sep, '/')
                if hasFormatErrors(contents=get_old_contents(input_api, path)):
                    old_version_has_errors = True
            except subprocess.CalledProcessError as e:
                old_version_has_errors = False
 
            if old_version_has_errors:
                print("WARNING: %s has existing and possibly new %s issues" %
                      (git_file.LocalPath(), identification))
            else:
                unformatted_files.append(filename)
 
    return unformatted_files
 
 

_CheckGeneratedBazelBUILDFiles()

PRESUBMIT._CheckGeneratedBazelBUILDFiles (   input_api,   output_api  )

protected

Definition at line 270 of file PRESUBMIT.py.

def _CheckGeneratedBazelBUILDFiles(input_api, output_api):
    if 'win32' in sys.platform:
      # TODO(crbug.com/skia/12541): Remove when Bazel builds work on Windows.
      # Note: `make` is not installed on Windows by default.
      return []
    if 'darwin' in sys.platform:
      # This takes too long on Mac with default settings. Probably due to sandboxing.
      return []
    for affected_file in input_api.AffectedFiles(include_deletes=True):
      affected_file_path = affected_file.LocalPath()
      if (affected_file_path.endswith('.go') or
          affected_file_path.endswith('BUILD.bazel')):
        return _RunCommandAndCheckGitDiff(output_api,
                                          ['make', '-C', 'bazel', 'generate_go'])
    return []  # No modified Go source files.
 
 

_CheckGitConflictMarkers()

PRESUBMIT._CheckGitConflictMarkers (   input_api,   output_api  )

protected

Definition at line 184 of file PRESUBMIT.py.

def _CheckGitConflictMarkers(input_api, output_api):
  pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$')
  results = []
  for f in input_api.AffectedFiles():
    for line_num, line in f.ChangedContents():
      if f.LocalPath().endswith('.md'):
        # First-level headers in markdown look a lot like version control
        # conflict markers. http://daringfireball.net/projects/markdown/basics
        continue
      if pattern.match(line):
        results.append(
            output_api.PresubmitError(
                'Git conflict markers found in %s:%d %s' % (
                    f.LocalPath(), line_num, line)))
  return results
 
 

_CheckGNFormatted()

PRESUBMIT._CheckGNFormatted (   input_api,   output_api  )

protected

Make sure any .gn files we're changing have been formatted.

Definition at line 153 of file PRESUBMIT.py.

def _CheckGNFormatted(input_api, output_api):
  """Make sure any .gn files we're changing have been formatted."""
  files = []
  for f in input_api.AffectedFiles(include_deletes=False):
    if (f.LocalPath().endswith('.gn') or
        f.LocalPath().endswith('.gni')):
      files.append(f)
  if not files:
    return []
 
  cmd = ['python3', os.path.join('bin', 'fetch-gn')]
  try:
    subprocess.check_output(cmd)
  except subprocess.CalledProcessError as e:
    return [output_api.PresubmitError(
        '`%s` failed:\n%s' % (' '.join(cmd), e.output))]
 
  results = []
  for f in files:
    gn = 'gn.exe' if 'win32' in sys.platform else 'gn'
    gn = os.path.join(input_api.PresubmitLocalPath(), 'bin', gn)
    cmd = [gn, 'format', '--dry-run', f.LocalPath()]
    try:
      subprocess.check_output(cmd)
    except subprocess.CalledProcessError:
      fix = 'bin/gn format ' + f.LocalPath()
      results.append(output_api.PresubmitError(
          '`%s` failed, try\n\t%s' % (' '.join(cmd), fix)))
  return results
 
 

_CheckGNIGenerated()

PRESUBMIT._CheckGNIGenerated (   input_api,   output_api  )

protected

Ensures that the generated *.gni files are current.

The Bazel project files are authoritative and some *.gni files are
generated from them using the exporter_tool. This check ensures they
are still current.

Definition at line 385 of file PRESUBMIT.py.

def _CheckGNIGenerated(input_api, output_api):
  """Ensures that the generated *.gni files are current.
 
  The Bazel project files are authoritative and some *.gni files are
  generated from them using the exporter_tool. This check ensures they
  are still current.
  """
  if 'win32' in sys.platform:
    # TODO(crbug.com/skia/12541): Remove when Bazel builds work on Windows.
    # Note: `make` is not installed on Windows by default.
    return [
        output_api.PresubmitPromptWarning(
            'Skipping Bazel=>GNI export check on Windows (unsupported platform).'
        )
    ]
  if 'darwin' in sys.platform:
      # This takes too long on Mac with default settings. Probably due to sandboxing.
      return []
  should_run = False
  for affected_file in input_api.AffectedFiles(include_deletes=True):
    affected_file_path = affected_file.LocalPath()
    if affected_file_path.endswith('BUILD.bazel') or affected_file_path.endswith('.gni'):
      should_run = True
  # Generate GNI files and verify no changes.
  if should_run:
    return _RunCommandAndCheckGitDiff(output_api,
            ['make', '-C', 'bazel', 'generate_gni'])
 
  # No Bazel build files changed.
  return []
 
 

_CheckIncludesFormatted()

PRESUBMIT._CheckIncludesFormatted (   input_api,   output_api  )

protected

Make sure #includes in files we're changing have been formatted.

Definition at line 201 of file PRESUBMIT.py.

def _CheckIncludesFormatted(input_api, output_api):
  """Make sure #includes in files we're changing have been formatted."""
  files = [str(f) for f in input_api.AffectedFiles() if f.Action() != 'D']
  cmd = ['python3',
         'tools/rewrite_includes.py',
         '--dry-run'] + files
  if 0 != subprocess.call(cmd):
    return [output_api.PresubmitError('`%s` failed' % ' '.join(cmd))]
  return []
 
 

_CheckLayering()

PRESUBMIT._CheckLayering (   input_api,   output_api  )

protected

Run VM layering check.

This check validates that sources from one layer do not reference sources
from another layer accidentally.

Definition at line 268 of file PRESUBMIT.py.

def _CheckLayering(input_api, output_api):
    """Run VM layering check.
 
  This check validates that sources from one layer do not reference sources
  from another layer accidentally.
  """
 
    # Run only if .cc or .h file was modified.
    if all(not is_cpp_file(f.LocalPath()) for f in input_api.AffectedFiles()):
        return []
 
    local_root = input_api.change.RepositoryRoot()
    compiler_layering_check = load_source(
        'compiler_layering_check',
        os.path.join(local_root, 'runtime', 'tools',
                     'compiler_layering_check.py'))
    errors = compiler_layering_check.DoCheck(local_root)
    embedder_layering_check = load_source(
        'embedder_layering_check',
        os.path.join(local_root, 'runtime', 'tools',
                     'embedder_layering_check.py'))
    errors += embedder_layering_check.DoCheck(local_root)
    if errors:
        return [
            output_api.PresubmitError(
                'Layering check violation for C++ sources.',
                long_text='\n'.join(errors))
        ]
 
    return []
 
 

_CheckNoNewObservatoryServiceTests()

PRESUBMIT._CheckNoNewObservatoryServiceTests (   input_api,   output_api  )

protected

Ensures that no new tests are added to the Observatory test suite.

Definition at line 496 of file PRESUBMIT.py.

def _CheckNoNewObservatoryServiceTests(input_api, output_api):
    """Ensures that no new tests are added to the Observatory test suite."""
    files = []
 
    for f in input_api.AffectedFiles(include_deletes=False):
        path = f.LocalPath()
        if is_dart_file(path) and path.startswith(
                "runtime/observatory/tests/service/") and f.Action(
                ) == 'A' and os.path.isfile(path):
            files.append(path)
 
    if not files:
        return []
 
    return [
        output_api.PresubmitError(
            'New VM service tests should be added to pkg/vm_service/test, ' +
            'not runtime/observatory/tests/service:\n' + '\n'.join(files))
    ]
 

_CheckPublicBzl()

PRESUBMIT._CheckPublicBzl (   input_api,   output_api  )

protected

Reminds devs to add/remove files from public.bzl.

Definition at line 330 of file PRESUBMIT.py.

def _CheckPublicBzl(input_api, output_api):
  """Reminds devs to add/remove files from public.bzl."""
  results = []
  public_bzl = ''
  with open('public.bzl', 'r', encoding='utf-8') as f:
    public_bzl = f.read().strip()
  for affected_file in input_api.AffectedFiles(include_deletes=True):
    # action is A for newly added, D for newly deleted, M for modified
    action = affected_file.Action()
    affected_file_path = affected_file.LocalPath()
    if ((affected_file_path.startswith("include") or affected_file_path.startswith("src")) and
        (affected_file_path.endswith(".cpp") or affected_file_path.endswith(".h") or
         affected_file_path.endswith(".mm"))):
      affected_file_path = '"' + affected_file_path + '"'
      if action == "D" and affected_file_path in public_bzl:
        results.append(output_api.PresubmitError(
              "Need to delete %s from public.bzl (or rename it)" % affected_file_path))
      elif action == "A" and affected_file_path not in public_bzl:
        results.append(output_api.PresubmitPromptWarning(
              "You may need to add %s to public.bzl" % affected_file_path))
  return results
 
 

_CheckReleaseNotesForPublicAPI()

PRESUBMIT._CheckReleaseNotesForPublicAPI (   input_api,   output_api  )

protected

Checks to see if a release notes file is added or edited with public API changes.

Definition at line 630 of file PRESUBMIT.py.

def _CheckReleaseNotesForPublicAPI(input_api, output_api):
  """Checks to see if a release notes file is added or edited with public API changes."""
  results = []
  public_api_changed = False
  release_file_changed = False
  for affected_file in input_api.AffectedFiles():
    affected_file_path = affected_file.LocalPath()
    file_path, file_ext = os.path.splitext(affected_file_path)
    # We only care about files that end in .h and are under the top-level
    # include dir, but not include/private.
    if (file_ext == '.h' and
        file_path.split(os.path.sep)[0] == 'include' and
        'private' not in file_path):
      public_api_changed = True
    elif os.path.dirname(file_path) == RELEASE_NOTES_DIR:
      release_file_changed = True
 
  if public_api_changed and not release_file_changed:
    results.append(output_api.PresubmitPromptWarning(
        'If this change affects a client API, please add a new summary '
        'file in the %s directory. More information can be found in '
        '%s.' % (RELEASE_NOTES_DIR, RELEASE_NOTES_README)))
  return results
 
 

_CheckStatusFiles()

PRESUBMIT._CheckStatusFiles (   input_api,   output_api  )

protected

Definition at line 198 of file PRESUBMIT.py.

def _CheckStatusFiles(input_api, output_api):
    local_root = input_api.change.RepositoryRoot()
    utils = load_source('utils', os.path.join(local_root, 'tools', 'utils.py'))
 
    dart = os.path.join(utils.CheckedInSdkPath(), 'bin', 'dart')
    lint = os.path.join(local_root, 'pkg', 'status_file', 'bin', 'lint.dart')
 
    windows = utils.GuessOS() == 'win32'
    if windows:
        dart += '.exe'
 
    if not os.path.isfile(dart):
        print('WARNING: dart not found: %s' % dart)
        return []
 
    if not os.path.isfile(lint):
        print('WARNING: Status file linter not found: %s' % lint)
        return []
 
    def HasFormatErrors(filename=None, filenames=None, contents=None):
        if filenames:
            # The status file linter doesn't support checking files in bulk.
            # Returning `True` causes `_CheckFormat` to fallback to check
            # formatting file by file below.
            return True
        args = [dart, lint] + (['-t'] if contents else [filename])
        process = subprocess.run(args, input=contents, text=True)
        return process.returncode != 0
 
    exclude_folders = [
        "pkg/status_file/test/data/",
        "pkg/front_end/",
    ]
    unformatted_files = _CheckFormat(input_api, "status file", ".status",
                                     windows, HasFormatErrors, exclude_folders)
 
    if unformatted_files:
        normalize = os.path.join(local_root, 'pkg', 'status_file', 'bin',
                                 'normalize.dart')
        lineSep = " \\\n"
        if windows:
            lineSep = " ^\n"
        return [
            output_api.PresubmitError(
                'Status files are not normalized.\n'
                'Fix these issues with:\n'
                '%s %s -w%s%s' % (dart, normalize, lineSep,
                                  lineSep.join(unformatted_files)))
        ]
 
    return []
 
 

_CheckTestMatrixValid()

PRESUBMIT._CheckTestMatrixValid (   input_api,   output_api  )

protected

Run script to check that the test matrix has no errors.

Definition at line 442 of file PRESUBMIT.py.

def _CheckTestMatrixValid(input_api, output_api):
    """Run script to check that the test matrix has no errors."""
 
    def test_matrix_filter(affected_file):
        """Only run test if either the test matrix or the code that
           validates it was modified."""
        path = affected_file.LocalPath()
        return (path == 'tools/bots/test_matrix.json' or
                path == 'tools/validate_test_matrix.dart' or
                path.startswith('pkg/smith/'))
 
    if len(
            input_api.AffectedFiles(
                include_deletes=False, file_filter=test_matrix_filter)) == 0:
        return []
 
    command = [
        'tools/sdks/dart-sdk/bin/dart',
        'tools/validate_test_matrix.dart',
    ]
    stdout = input_api.subprocess.check_output(command).strip()
    if not stdout:
        return []
    else:
        return [
            output_api.PresubmitError(
                'The test matrix is not valid:', long_text=stdout)
        ]
 
 

_CheckTopReleaseNotesChanged()

PRESUBMIT._CheckTopReleaseNotesChanged (   input_api,   output_api  )

protected

Warns if the top level release notes file was changed.

The top level file is now auto-edited, and new release notes should
be added to the RELEASE_NOTES_DIR directory

Definition at line 655 of file PRESUBMIT.py.

def _CheckTopReleaseNotesChanged(input_api, output_api):
  """Warns if the top level release notes file was changed.
 
  The top level file is now auto-edited, and new release notes should
  be added to the RELEASE_NOTES_DIR directory"""
  results = []
  top_relnotes_changed = False
  release_file_changed = False
  for affected_file in input_api.AffectedFiles():
    affected_file_path = affected_file.LocalPath()
    file_path, file_ext = os.path.splitext(affected_file_path)
    if affected_file_path == RELEASE_NOTES_FILE_NAME:
      top_relnotes_changed = True
    elif os.path.dirname(file_path) == RELEASE_NOTES_DIR:
      release_file_changed = True
  # When relnotes_util is run it will modify RELEASE_NOTES_FILE_NAME
  # and delete the individual note files in RELEASE_NOTES_DIR.
  # So, if both paths are modified do not emit a warning.
  if top_relnotes_changed and not release_file_changed:
    results.append(output_api.PresubmitPromptWarning(
        'Do not edit %s directly. %s is automatically edited during the '
        'release process. Release notes should be added as new files in '
        'the %s directory. More information can be found in %s.' % (RELEASE_NOTES_FILE_NAME,
                                                                    RELEASE_NOTES_FILE_NAME,
                                                                    RELEASE_NOTES_DIR,
                                                                    RELEASE_NOTES_README)))
  return results
 
 

_CheckValidHostsInDEPS()

PRESUBMIT._CheckValidHostsInDEPS (   input_api,   output_api  )

protected

Checks that DEPS file deps are from allowed_hosts.

Definition at line 251 of file PRESUBMIT.py.

def _CheckValidHostsInDEPS(input_api, output_api):
    """Checks that DEPS file deps are from allowed_hosts."""
    # Run only if DEPS file has been modified to annoy fewer bystanders.
    if all(f.LocalPath() != 'DEPS' for f in input_api.AffectedFiles()):
        return []
    # Outsource work to gclient verify
    try:
        input_api.subprocess.check_output(['gclient', 'verify'])
        return []
    except input_api.subprocess.CalledProcessError as error:
        return [
            output_api.PresubmitError(
                'DEPS file must have only dependencies from allowed hosts.',
                long_text=error.output)
        ]
 
 

_CommonChecks()

PRESUBMIT._CommonChecks ( input_api  , output_api    )

protected

Presubmit checks common to upload and commit.

Definition at line 516 of file PRESUBMIT.py.

def _CommonChecks(input_api, output_api):
    results = []
    results.extend(_CheckValidHostsInDEPS(input_api, output_api))
    results.extend(_CheckDartFormat(input_api, output_api))
    results.extend(_CheckStatusFiles(input_api, output_api))
    results.extend(_CheckLayering(input_api, output_api))
    results.extend(_CheckClangTidy(input_api, output_api))
    results.extend(_CheckClangFormat(input_api, output_api))
    results.extend(_CheckTestMatrixValid(input_api, output_api))
    results.extend(
        input_api.canned_checks.CheckPatchFormatted(input_api, output_api))
    results.extend(_CheckCopyrightYear(input_api, output_api))
    results.extend(_CheckAnalyzerFiles(input_api, output_api))
    results.extend(_CheckNoNewObservatoryServiceTests(input_api, output_api))
    return results
 
 

_CopyrightChecks()

PRESUBMIT._CopyrightChecks (   input_api,   output_api,   source_file_filter = None  )

protected

Definition at line 115 of file PRESUBMIT.py.

def _CopyrightChecks(input_api, output_api, source_file_filter=None):
  results = []
  year_pattern = r'\d{4}'
  year_range_pattern = r'%s(-%s)?' % (year_pattern, year_pattern)
  years_pattern = r'%s(,%s)*,?' % (year_range_pattern, year_range_pattern)
  copyright_pattern = (
      r'Copyright (\‍([cC]\‍) )?%s \w+' % years_pattern)
 
  for affected_file in input_api.AffectedSourceFiles(source_file_filter):
    if ('third_party/' in affected_file.LocalPath() or
        'tests/sksl/' in affected_file.LocalPath() or
        'bazel/rbe/' in affected_file.LocalPath() or
        'bazel/external/' in affected_file.LocalPath() or
        'bazel/exporter/interfaces/mocks/' in affected_file.LocalPath()):
      continue
    contents = input_api.ReadFile(affected_file, 'rb')
    if not re.search(copyright_pattern, contents):
      results.append(output_api.PresubmitError(
          '%s is missing a correct copyright header.' % affected_file))
  return results
 
 

_IfDefChecks()

PRESUBMIT._IfDefChecks (   input_api,   output_api  )

protected

Ensures if/ifdef are not before includes. See skbug/3362 for details.

Definition at line 74 of file PRESUBMIT.py.

def _IfDefChecks(input_api, output_api):
  """Ensures if/ifdef are not before includes. See skbug/3362 for details."""
  comment_block_start_pattern = re.compile('^\s*\/\*.*$')
  comment_block_middle_pattern = re.compile('^\s+\*.*')
  comment_block_end_pattern = re.compile('^\s+\*\/.*$')
  single_line_comment_pattern = re.compile('^\s*//.*$')
  def is_comment(line):
    return (comment_block_start_pattern.match(line) or
            comment_block_middle_pattern.match(line) or
            comment_block_end_pattern.match(line) or
            single_line_comment_pattern.match(line))
 
  empty_line_pattern = re.compile('^\s*$')
  def is_empty_line(line):
    return empty_line_pattern.match(line)
 
  failing_files = []
  for affected_file in input_api.AffectedSourceFiles(None):
    affected_file_path = affected_file.LocalPath()
    if affected_file_path.endswith('.cpp') or affected_file_path.endswith('.h'):
      f = open(affected_file_path)
      for line in f:
        if is_comment(line) or is_empty_line(line):
          continue
        # The below will be the first real line after comments and newlines.
        if line.startswith('#if 0 '):
          pass
        elif line.startswith('#if ') or line.startswith('#ifdef '):
          failing_files.append(affected_file_path)
        break
 
  results = []
  if failing_files:
    results.append(
        output_api.PresubmitError(
            'The following files have #if or #ifdef before includes:\n%s\n\n'
            'See https://bug.skia.org/3362 for why this should be fixed.' %
                '\n'.join(failing_files)))
  return results
 
 

_InfraTests()

PRESUBMIT._InfraTests (   input_api,   output_api  )

protected

Run the infra tests.

Definition at line 137 of file PRESUBMIT.py.

def _InfraTests(input_api, output_api):
  """Run the infra tests."""
  results = []
  if not any(f.LocalPath().startswith('infra')
             for f in input_api.AffectedFiles()):
    return results
 
  cmd = ['python3', os.path.join('infra', 'bots', 'infra_tests.py')]
  try:
    subprocess.check_output(cmd)
  except subprocess.CalledProcessError as e:
    results.append(output_api.PresubmitError(
        '`%s` failed:\n%s' % (' '.join(cmd), e.output)))
  return results
 
 

_JsonChecks()

PRESUBMIT._JsonChecks (   input_api,   output_api  )

protected

Run checks on any modified json files.

Definition at line 51 of file PRESUBMIT.py.

def _JsonChecks(input_api, output_api):
  """Run checks on any modified json files."""
  failing_files = []
  for affected_file in input_api.AffectedFiles(None):
    affected_file_path = affected_file.LocalPath()
    is_json = affected_file_path.endswith('.json')
    is_metadata = (affected_file_path.startswith('site/') and
                   affected_file_path.endswith('/METADATA'))
    if is_json or is_metadata:
      try:
        input_api.json.load(open(affected_file_path, 'r'))
      except ValueError:
        failing_files.append(affected_file_path)
 
  results = []
  if failing_files:
    results.append(
        output_api.PresubmitError(
            'The following files contain invalid json:\n%s\n\n' %
                '\n'.join(failing_files)))
  return results
 
 

_RegenerateAllExamplesCPP()

PRESUBMIT._RegenerateAllExamplesCPP (   input_api,   output_api  )

protected

Regenerates all_examples.cpp if an example was added or deleted.

Definition at line 224 of file PRESUBMIT.py.

def _RegenerateAllExamplesCPP(input_api, output_api):
  """Regenerates all_examples.cpp if an example was added or deleted."""
  if not any(f.LocalPath().startswith('docs/examples/')
             for f in input_api.AffectedFiles()):
    return []
  command_str = 'tools/fiddle/make_all_examples_cpp.py'
  cmd = ['python3', command_str]
  if 0 != subprocess.call(cmd):
    return [output_api.PresubmitError('`%s` failed' % ' '.join(cmd))]
 
  results = []
  git_diff_output = input_api.subprocess.check_output(
      ['git', 'diff', '--no-ext-diff'])
  if git_diff_output:
    results += [output_api.PresubmitError(
        'Diffs found after running "%s":\n\n%s\n'
        'Please commit or discard the above changes.' % (
            command_str,
            git_diff_output,
        )
    )]
  return results
 
 

_RunCommandAndCheckGitDiff()

PRESUBMIT._RunCommandAndCheckGitDiff (   output_api,   command  )

protected

Run an arbitrary command. Fail if it produces any diffs.

Definition at line 353 of file PRESUBMIT.py.

def _RunCommandAndCheckGitDiff(output_api, command):
  """Run an arbitrary command. Fail if it produces any diffs."""
  command_str = ' '.join(command)
  results = []
 
  try:
    output = subprocess.check_output(
        command,
        stderr=subprocess.STDOUT, encoding='utf-8')
  except subprocess.CalledProcessError as e:
    results += [output_api.PresubmitError(
        'Command "%s" returned non-zero exit code %d. Output: \n\n%s' % (
            command_str,
            e.returncode,
            e.output,
        )
    )]
 
  git_diff_output = subprocess.check_output(
      ['git', 'diff', '--no-ext-diff'], encoding='utf-8')
  if git_diff_output:
    results += [output_api.PresubmitError(
        'Diffs found after running "%s":\n\n%s\n'
        'Please commit or discard the above changes.' % (
            command_str,
            git_diff_output,
        )
    )]
 
  return results
 
 

CheckChange()

PRESUBMIT.CheckChange	(		input_api,
			output_api
	)

Definition at line 41 of file PRESUBMIT.py.

def CheckChange(input_api, output_api):
    errors = []
 
    # If the `lib` dir is altered, we also require a change to the pubspec.yaml
    # of both this package and the `macros` package.
    lib_changed = any(file.LocalPath().startswith('pkg/_macros/lib')
                      for file in input_api.AffectedFiles())
    if lib_changed:
        errors += EnsurePubspecAndChangelogAltered(input_api, '_macros')
        errors += EnsurePubspecAndChangelogAltered(input_api, 'macros')
 
    if errors:
        return [
            output_api.PresubmitError(
                'pkg/_macros presubmit/PRESUBMIT.py failure(s):',
                long_text='\n\n'.join(errors))
        ]
 
    return []

CheckChangeOnCommit()

PRESUBMIT.CheckChangeOnCommit	(	input_api	,
		output_api
	)

Presubmit checks for the change on commit.

Definition at line 66 of file PRESUBMIT.py.

def CheckChangeOnCommit(input_api, output_api):
    return runSmokeTest(input_api, output_api)
 
 

CheckChangeOnUpload()

PRESUBMIT.CheckChangeOnUpload	(	input_api	,
		output_api
	)

Presubmit checks for the change on upload.

Definition at line 70 of file PRESUBMIT.py.

def CheckChangeOnUpload(input_api, output_api):
    return runSmokeTest(input_api, output_api)

CheckFormatted()

PRESUBMIT.CheckFormatted	(		input_api,
			output_api
	)

Definition at line 62 of file PRESUBMIT.py.

def CheckFormatted(input_api, output_api):
 
    def convert_warning_to_error(presubmit_result):
        if not presubmit_result.fatal:
            # Convert this warning to an error.
            result_json = presubmit_result.json_format()
            return output_api.PresubmitError(
                message=result_json['message'],
                items=result_json['items'],
                long_text=result_json['long_text'])
        return presubmit_result
 
    results = input_api.canned_checks.CheckPatchFormatted(input_api, output_api)
    return [convert_warning_to_error(r) for r in results]
 
 

CheckGn()

PRESUBMIT.CheckGn	(		input_api,
			output_api
	)

Definition at line 58 of file PRESUBMIT.py.

def CheckGn(input_api, output_api):
    return input_api.canned_checks.CheckGNFormatted(input_api, output_api)
 
 

CheckMemcpy()

PRESUBMIT.CheckMemcpy

(

filename

)

Definition at line 17 of file PRESUBMIT.py.

def CheckMemcpy(filename):
    if filename.endswith(os.path.join('platform', 'globals.h')) or \
       filename.find('third_party') != -1:
        return 0
    fh = open(filename, 'r')
    content = fh.read()
    match = re.search('\\bmemcpy\\b', content)
    if match:
        offset = match.start()
        end_of_line = content.index('\n', offset)
        # We allow explicit use of memcpy with an opt-in via NOLINT
        if 'NOLINT' not in content[offset:end_of_line]:
            line_number = content[0:match.start()].count('\n') + 1
            print("%s:%d: use of memcpy is forbidden" % (filename, line_number))
            return 1
    return 0
 
 

CheckNodeTextExpectationsCollectorUpdatingIsDisabled()

PRESUBMIT.CheckNodeTextExpectationsCollectorUpdatingIsDisabled	(		input_api,
			output_api
	)

Definition at line 18 of file PRESUBMIT.py.

def CheckNodeTextExpectationsCollectorUpdatingIsDisabled(input_api, output_api):
    local_root = input_api.change.RepositoryRoot()
    node_text_expectations_file = os.path.join(local_root, 'pkg', 'analyzer',
                                               'test', 'src', 'dart',
                                               'resolution',
                                               'node_text_expectations.dart')
    for git_file in input_api.AffectedTestableFiles():
        filename = git_file.AbsoluteLocalPath()
        if (filename == node_text_expectations_file):
            isEnabledLine = re.compile('static const updatingIsEnabled = (.*);')
            for line in git_file.NewContents():
                m = isEnabledLine.search(line)
                if (m is not None):
                    value = m.group(1)
                    if (value == 'false'):
                        return []
                    else:
                        return [
                            output_api.PresubmitError(
                                'NodeTextExpectationsCollector.updatingIsEnabled '
                                'must be `false`')
                        ]
            return [
                output_api.PresubmitError(
                    'Could not validate '
                    'NodeTextExpectationsCollector.updatingIsEnabled')
            ]
    return []

EnsurePubspecAndChangelogAltered()

PRESUBMIT.EnsurePubspecAndChangelogAltered	(		input_api,
			package_name
	)

Definition at line 20 of file PRESUBMIT.py.

def EnsurePubspecAndChangelogAltered(input_api, package_name):
    errors = []
    package_path = 'pkg/%s' % package_name
    pubspec_path = '%s/pubspec.yaml' % package_path
    pubspec_changed = any(file.LocalPath() == pubspec_path
                          for file in input_api.change.AffectedFiles())
    if not pubspec_changed:
        errors.append(
            ('The pkg/_macros/lib dir was altered but the version of %s was '
             'not bumped. See pkg/_macros/CONTRIBUTING.md' % package_path))
 
    changelog_path = '%s/CHANGELOG.md' % package_path
    changelog_changed = any(file.LocalPath() == changelog_path
                            for file in input_api.change.AffectedFiles())
    if not changelog_changed:
        errors.append(
            ('The pkg/_macros/lib dir was altered but the CHANGELOG.md of %s '
             'was not edited. See pkg/_macros/CONTRIBUTING.md' % package_path))
    return errors
 
# Invoked on upload and commit.

files_to_check_for_format()

PRESUBMIT.files_to_check_for_format	(		input_api,
			extension,
			exclude_folders
	)

Definition at line 41 of file PRESUBMIT.py.

def files_to_check_for_format(input_api, extension, exclude_folders):
    files = []
    exclude_folders += [
        "pkg/front_end/testcases/", "pkg/front_end/parser_testcases/"
    ]
    for git_file in input_api.AffectedTextFiles():
        local_path = git_file.LocalPath()
        if not local_path.endswith(extension):
            continue
        if any([local_path.startswith(f) for f in exclude_folders]):
            continue
        files.append(git_file)
    return files
 
 

get_old_contents()

PRESUBMIT.get_old_contents	(		input_api,
			path
	)

Definition at line 33 of file PRESUBMIT.py.

def get_old_contents(input_api, path):
    local_root = input_api.change.RepositoryRoot()
    upstream = input_api.change._upstream
    return scm.GIT.Capture(['show', upstream + ':' + path],
                           cwd=local_root,
                           strip_out=False)
 
 

is_cpp_file()

PRESUBMIT.is_cpp_file

(

path

)

Definition at line 25 of file PRESUBMIT.py.

def is_cpp_file(path):
    return path.endswith('.cc') or path.endswith('.h')
 
 

is_dart_file()

PRESUBMIT.is_dart_file

(

path

)

Definition at line 29 of file PRESUBMIT.py.

def is_dart_file(path):
    return path.endswith('.dart')
 
 

load_source()

PRESUBMIT.load_source	(		modname,
			filename
	)

Definition at line 19 of file PRESUBMIT.py.

def load_source(modname, filename):
    loader = importlib.machinery.SourceFileLoader(modname, filename)
    spec = importlib.util.spec_from_file_location(modname,
                                                  filename,
                                                  loader=loader)
    module = importlib.util.module_from_spec(spec)
    # The module is always executed and not cached in sys.modules.
    # Uncomment the following line to cache the module.
    # sys.modules[module.__name__] = module
    loader.exec_module(module)
    return module
 
 

PostUploadHook()

PRESUBMIT.PostUploadHook	(		gerrit,
			change,
			output_api
	)

git cl upload will call this hook after the issue is created/modified.

This hook does the following:
* Adds a link to preview docs changes if there are any docs changes in the CL.
* Adds 'No-Try: true' if the CL contains only docs changes.

Definition at line 684 of file PRESUBMIT.py.

def PostUploadHook(gerrit, change, output_api):
  """git cl upload will call this hook after the issue is created/modified.
 
  This hook does the following:
  * Adds a link to preview docs changes if there are any docs changes in the CL.
  * Adds 'No-Try: true' if the CL contains only docs changes.
  """
  if not change.issue:
    return []
 
  # Skip PostUploadHooks for all auto-commit service account bots. New
  # patchsets (caused due to PostUploadHooks) invalidates the CQ+2 vote from
  # the "--use-commit-queue" flag to "git cl upload".
  for suffix in SERVICE_ACCOUNT_SUFFIX:
    if change.author_email.endswith(suffix):
      return []
 
  results = []
  at_least_one_docs_change = False
  all_docs_changes = True
  for affected_file in change.AffectedFiles():
    affected_file_path = affected_file.LocalPath()
    file_path, _ = os.path.splitext(affected_file_path)
    if 'site' == file_path.split(os.path.sep)[0]:
      at_least_one_docs_change = True
    else:
      all_docs_changes = False
    if at_least_one_docs_change and not all_docs_changes:
      break
 
  footers = change.GitFootersFromDescription()
  description_changed = False
 
  # If the change includes only doc changes then add No-Try: true in the
  # CL's description if it does not exist yet.
  if all_docs_changes and 'true' not in footers.get('No-Try', []):
    description_changed = True
    change.AddDescriptionFooter('No-Try', 'true')
    results.append(
        output_api.PresubmitNotifyResult(
            'This change has only doc changes. Automatically added '
            '\'No-Try: true\' to the CL\'s description'))
 
  # If the description has changed update it.
  if description_changed:
    gerrit.UpdateDescription(
        change.FullDescriptionText(), change.issue)
 
  return results
 
 

RunLint()

PRESUBMIT.RunLint	(		input_api,
			output_api
	)

Definition at line 35 of file PRESUBMIT.py.

def RunLint(input_api, output_api):
    result = []
    cpplint._cpplint_state.ResetErrorCounts()
    memcpy_match_count = 0
    # Find all .cc and .h files in the change list.
    for git_file in input_api.AffectedTextFiles():
        filename = git_file.AbsoluteLocalPath()
        if filename.endswith('.cc') or (
                # cpplint complains about the style of #ifndefs in our .pbzero.h
                # files, but they are generated by the protozero compiler, so we
                # can't fix this.
                not filename.endswith('.pbzero.h') and filename.endswith('.h')):
            # Run cpplint on the file.
            cpplint.ProcessFile(filename, 1)
            # Check for memcpy use.
            memcpy_match_count += CheckMemcpy(filename)
 
    # Report a presubmit error if any of the files had an error.
    if cpplint._cpplint_state.error_count > 0 or memcpy_match_count > 0:
        result = [output_api.PresubmitError('Failed cpplint check.')]
    return result
 
 

runSmokeTest()

PRESUBMIT.runSmokeTest	(		input_api,
			output_api
	)

Definition at line 32 of file PRESUBMIT.py.

def runSmokeTest(input_api, output_api):
    local_root = input_api.change.RepositoryRoot()
    utils = load_source('utils', os.path.join(local_root, 'tools', 'utils.py'))
    dart = os.path.join(utils.CheckedInSdkPath(), 'bin', 'dart')
    test_helper = os.path.join(local_root, 'pkg', 'front_end',
                               'presubmit_helper.dart')
 
    windows = utils.GuessOS() == 'win32'
    if windows:
        dart += '.exe'
 
    if not os.path.isfile(dart):
        print('WARNING: dart not found: %s' % dart)
        return []
 
    if not os.path.isfile(test_helper):
        print('WARNING: CFE et al presubmit_helper not found: %s' % test_helper)
        return []
 
    args = [dart, test_helper, input_api.PresubmitLocalPath()]
    process = subprocess.Popen(args,
                               stdout=subprocess.PIPE,
                               stdin=subprocess.PIPE)
    outs, _ = process.communicate()
 
    if process.returncode != 0:
        return [
            output_api.PresubmitError('CFE et al presubmit script failure(s):',
                                      long_text=outs)
        ]
 
    return []
 
 

Variable Documentation

GOLD_TRYBOT_URL

str PRESUBMIT.GOLD_TRYBOT_URL = 'https://gold.skia.org/search?issue='

Definition at line 25 of file PRESUBMIT.py.

PRESUBMIT_VERSION

str PRESUBMIT.PRESUBMIT_VERSION = '2.0.0'

Definition at line 11 of file PRESUBMIT.py.

RELEASE_NOTES_DIR

str PRESUBMIT.RELEASE_NOTES_DIR = 'relnotes'

Definition at line 21 of file PRESUBMIT.py.

RELEASE_NOTES_FILE_NAME

str PRESUBMIT.RELEASE_NOTES_FILE_NAME = 'RELEASE_NOTES.md'

Definition at line 22 of file PRESUBMIT.py.

RELEASE_NOTES_README

str PRESUBMIT.RELEASE_NOTES_README = '//relnotes/README.md'

Definition at line 23 of file PRESUBMIT.py.

SERVICE_ACCOUNT_SUFFIX

list PRESUBMIT.SERVICE_ACCOUNT_SUFFIX

Initial value:

=  [
    '@%s.iam.gserviceaccount.com' % project for project in [
        'skia-buildbots.google.com', 'skia-swarming-bots', 'skia-public',
        'skia-corp.google.com', 'chops-service-accounts']]

Definition at line 27 of file PRESUBMIT.py.

USE_PYTHON3

bool PRESUBMIT.USE_PYTHON3 = True

Definition at line 16 of file PRESUBMIT.py.