Clone of chromium aad1ce808763f59c7a3753e08f1500a104ecc6fd refs/remotes/origin/HEAD
diff --git a/PRESUBMIT.py b/PRESUBMIT.py
new file mode 100644
index 0000000..9949150
--- /dev/null
+++ b/PRESUBMIT.py
@@ -0,0 +1,1708 @@
+# Copyright (c) 2012 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.
+
+"""Top-level presubmit script for Chromium.
+
+See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
+for more details about the presubmit API built into gcl.
+"""
+
+
+import re
+import sys
+
+
+_EXCLUDED_PATHS = (
+ r"^breakpad[\\\/].*",
+ r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_rules.py",
+ r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_simple.py",
+ r"^native_client_sdk[\\\/]src[\\\/]tools[\\\/].*.mk",
+ r"^net[\\\/]tools[\\\/]spdyshark[\\\/].*",
+ r"^skia[\\\/].*",
+ r"^v8[\\\/].*",
+ r".*MakeFile$",
+ r".+_autogen\.h$",
+ r".+[\\\/]pnacl_shim\.c$",
+ r"^gpu[\\\/]config[\\\/].*_list_json\.cc$",
+ r"^chrome[\\\/]browser[\\\/]resources[\\\/]pdf[\\\/]index.js"
+)
+
+# The NetscapePlugIn library is excluded from pan-project as it will soon
+# be deleted together with the rest of the NPAPI and it's not worthwhile to
+# update the coding style until then.
+_TESTRUNNER_PATHS = (
+ r"^content[\\\/]shell[\\\/]tools[\\\/]plugin[\\\/].*",
+)
+
+# Fragment of a regular expression that matches C++ and Objective-C++
+# implementation files.
+_IMPLEMENTATION_EXTENSIONS = r'\.(cc|cpp|cxx|mm)$'
+
+# Regular expression that matches code only used for test binaries
+# (best effort).
+_TEST_CODE_EXCLUDED_PATHS = (
+ r'.*[\\\/](fake_|test_|mock_).+%s' % _IMPLEMENTATION_EXTENSIONS,
+ r'.+_test_(base|support|util)%s' % _IMPLEMENTATION_EXTENSIONS,
+ r'.+_(api|browser|kif|perf|pixel|unit|ui)?test(_[a-z]+)?%s' %
+ _IMPLEMENTATION_EXTENSIONS,
+ r'.+profile_sync_service_harness%s' % _IMPLEMENTATION_EXTENSIONS,
+ r'.*[\\\/](test|tool(s)?)[\\\/].*',
+ # content_shell is used for running layout tests.
+ r'content[\\\/]shell[\\\/].*',
+ # At request of folks maintaining this folder.
+ r'chrome[\\\/]browser[\\\/]automation[\\\/].*',
+ # Non-production example code.
+ r'mojo[\\\/]examples[\\\/].*',
+ # Launcher for running iOS tests on the simulator.
+ r'testing[\\\/]iossim[\\\/]iossim\.mm$',
+)
+
+_TEST_ONLY_WARNING = (
+ 'You might be calling functions intended only for testing from\n'
+ 'production code. It is OK to ignore this warning if you know what\n'
+ 'you are doing, as the heuristics used to detect the situation are\n'
+ 'not perfect. The commit queue will not block on this warning.')
+
+
+_INCLUDE_ORDER_WARNING = (
+ 'Your #include order seems to be broken. Send mail to\n'
+ 'marja@chromium.org if this is not the case.')
+
+
+_BANNED_OBJC_FUNCTIONS = (
+ (
+ 'addTrackingRect:',
+ (
+ 'The use of -[NSView addTrackingRect:owner:userData:assumeInside:] is'
+ 'prohibited. Please use CrTrackingArea instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ False,
+ ),
+ (
+ r'/NSTrackingArea\W',
+ (
+ 'The use of NSTrackingAreas is prohibited. Please use CrTrackingArea',
+ 'instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ False,
+ ),
+ (
+ 'convertPointFromBase:',
+ (
+ 'The use of -[NSView convertPointFromBase:] is almost certainly wrong.',
+ 'Please use |convertPoint:(point) fromView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+ (
+ 'convertPointToBase:',
+ (
+ 'The use of -[NSView convertPointToBase:] is almost certainly wrong.',
+ 'Please use |convertPoint:(point) toView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+ (
+ 'convertRectFromBase:',
+ (
+ 'The use of -[NSView convertRectFromBase:] is almost certainly wrong.',
+ 'Please use |convertRect:(point) fromView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+ (
+ 'convertRectToBase:',
+ (
+ 'The use of -[NSView convertRectToBase:] is almost certainly wrong.',
+ 'Please use |convertRect:(point) toView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+ (
+ 'convertSizeFromBase:',
+ (
+ 'The use of -[NSView convertSizeFromBase:] is almost certainly wrong.',
+ 'Please use |convertSize:(point) fromView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+ (
+ 'convertSizeToBase:',
+ (
+ 'The use of -[NSView convertSizeToBase:] is almost certainly wrong.',
+ 'Please use |convertSize:(point) toView:nil| instead.',
+ 'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
+ ),
+ True,
+ ),
+)
+
+
+_BANNED_CPP_FUNCTIONS = (
+ # Make sure that gtest's FRIEND_TEST() macro is not used; the
+ # FRIEND_TEST_ALL_PREFIXES() macro from base/gtest_prod_util.h should be
+ # used instead since that allows for FLAKY_ and DISABLED_ prefixes.
+ (
+ 'FRIEND_TEST(',
+ (
+ 'Chromium code should not use gtest\'s FRIEND_TEST() macro. Include',
+ 'base/gtest_prod_util.h and use FRIEND_TEST_ALL_PREFIXES() instead.',
+ ),
+ False,
+ (),
+ ),
+ (
+ 'ScopedAllowIO',
+ (
+ 'New code should not use ScopedAllowIO. Post a task to the blocking',
+ 'pool or the FILE thread instead.',
+ ),
+ True,
+ (
+ r"^base[\\\/]process[\\\/]process_metrics_linux\.cc$",
+ r"^chrome[\\\/]browser[\\\/]chromeos[\\\/]boot_times_loader\.cc$",
+ r"^components[\\\/]crash[\\\/]app[\\\/]breakpad_mac\.mm$",
+ r"^content[\\\/]shell[\\\/]browser[\\\/]shell_browser_main\.cc$",
+ r"^content[\\\/]shell[\\\/]browser[\\\/]shell_message_filter\.cc$",
+ r"^mojo[\\\/]edk[\\\/]embedder[\\\/]" +
+ r"simple_platform_shared_buffer_posix\.cc$",
+ r"^net[\\\/]disk_cache[\\\/]cache_util\.cc$",
+ r"^net[\\\/]url_request[\\\/]test_url_fetcher_factory\.cc$",
+ ),
+ ),
+ (
+ 'SkRefPtr',
+ (
+ 'The use of SkRefPtr is prohibited. ',
+ 'Please use skia::RefPtr instead.'
+ ),
+ True,
+ (),
+ ),
+ (
+ 'SkAutoRef',
+ (
+ 'The indirect use of SkRefPtr via SkAutoRef is prohibited. ',
+ 'Please use skia::RefPtr instead.'
+ ),
+ True,
+ (),
+ ),
+ (
+ 'SkAutoTUnref',
+ (
+ 'The use of SkAutoTUnref is dangerous because it implicitly ',
+ 'converts to a raw pointer. Please use skia::RefPtr instead.'
+ ),
+ True,
+ (),
+ ),
+ (
+ 'SkAutoUnref',
+ (
+ 'The indirect use of SkAutoTUnref through SkAutoUnref is dangerous ',
+ 'because it implicitly converts to a raw pointer. ',
+ 'Please use skia::RefPtr instead.'
+ ),
+ True,
+ (),
+ ),
+ (
+ r'/HANDLE_EINTR\(.*close',
+ (
+ 'HANDLE_EINTR(close) is invalid. If close fails with EINTR, the file',
+ 'descriptor will be closed, and it is incorrect to retry the close.',
+ 'Either call close directly and ignore its return value, or wrap close',
+ 'in IGNORE_EINTR to use its return value. See http://crbug.com/269623'
+ ),
+ True,
+ (),
+ ),
+ (
+ r'/IGNORE_EINTR\((?!.*close)',
+ (
+ 'IGNORE_EINTR is only valid when wrapping close. To wrap other system',
+ 'calls, use HANDLE_EINTR. See http://crbug.com/269623',
+ ),
+ True,
+ (
+ # Files that #define IGNORE_EINTR.
+ r'^base[\\\/]posix[\\\/]eintr_wrapper\.h$',
+ r'^ppapi[\\\/]tests[\\\/]test_broker\.cc$',
+ ),
+ ),
+ (
+ r'/v8::Extension\(',
+ (
+ 'Do not introduce new v8::Extensions into the code base, use',
+ 'gin::Wrappable instead. See http://crbug.com/334679',
+ ),
+ True,
+ (
+ r'extensions[\\\/]renderer[\\\/]safe_builtins\.*',
+ ),
+ ),
+)
+
+_IPC_ENUM_TRAITS_DEPRECATED = (
+ 'You are using IPC_ENUM_TRAITS() in your code. It has been deprecated.\n'
+ 'See http://www.chromium.org/Home/chromium-security/education/security-tips-for-ipc')
+
+
+_VALID_OS_MACROS = (
+ # Please keep sorted.
+ 'OS_ANDROID',
+ 'OS_ANDROID_HOST',
+ 'OS_BSD',
+ 'OS_CAT', # For testing.
+ 'OS_CHROMEOS',
+ 'OS_FREEBSD',
+ 'OS_IOS',
+ 'OS_LINUX',
+ 'OS_MACOSX',
+ 'OS_NACL',
+ 'OS_OPENBSD',
+ 'OS_POSIX',
+ 'OS_QNX',
+ 'OS_SOLARIS',
+ 'OS_WIN',
+)
+
+
+def _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api):
+ """Attempts to prevent use of functions intended only for testing in
+ non-testing code. For now this is just a best-effort implementation
+ that ignores header files and may have some false positives. A
+ better implementation would probably need a proper C++ parser.
+ """
+ # We only scan .cc files and the like, as the declaration of
+ # for-testing functions in header files are hard to distinguish from
+ # calls to such functions without a proper C++ parser.
+ file_inclusion_pattern = r'.+%s' % _IMPLEMENTATION_EXTENSIONS
+
+ base_function_pattern = r'[ :]test::[^\s]+|ForTest(ing)?|for_test(ing)?'
+ inclusion_pattern = input_api.re.compile(r'(%s)\s*\(' % base_function_pattern)
+ comment_pattern = input_api.re.compile(r'//.*(%s)' % base_function_pattern)
+ exclusion_pattern = input_api.re.compile(
+ r'::[A-Za-z0-9_]+(%s)|(%s)[^;]+\{' % (
+ base_function_pattern, base_function_pattern))
+
+ def FilterFile(affected_file):
+ black_list = (_EXCLUDED_PATHS +
+ _TEST_CODE_EXCLUDED_PATHS +
+ input_api.DEFAULT_BLACK_LIST)
+ return input_api.FilterSourceFile(
+ affected_file,
+ white_list=(file_inclusion_pattern, ),
+ black_list=black_list)
+
+ problems = []
+ for f in input_api.AffectedSourceFiles(FilterFile):
+ local_path = f.LocalPath()
+ for line_number, line in f.ChangedContents():
+ if (inclusion_pattern.search(line) and
+ not comment_pattern.search(line) and
+ not exclusion_pattern.search(line)):
+ problems.append(
+ '%s:%d\n %s' % (local_path, line_number, line.strip()))
+
+ if problems:
+ return [output_api.PresubmitPromptOrNotify(_TEST_ONLY_WARNING, problems)]
+ else:
+ return []
+
+
+def _CheckNoIOStreamInHeaders(input_api, output_api):
+ """Checks to make sure no .h files include <iostream>."""
+ files = []
+ pattern = input_api.re.compile(r'^#include\s*<iostream>',
+ input_api.re.MULTILINE)
+ for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
+ if not f.LocalPath().endswith('.h'):
+ continue
+ contents = input_api.ReadFile(f)
+ if pattern.search(contents):
+ files.append(f)
+
+ if len(files):
+ return [ output_api.PresubmitError(
+ 'Do not #include <iostream> in header files, since it inserts static '
+ 'initialization into every file including the header. Instead, '
+ '#include <ostream>. See http://crbug.com/94794',
+ files) ]
+ return []
+
+
+def _CheckNoUNIT_TESTInSourceFiles(input_api, output_api):
+ """Checks to make sure no source files use UNIT_TEST"""
+ problems = []
+ for f in input_api.AffectedFiles():
+ if (not f.LocalPath().endswith(('.cc', '.mm'))):
+ continue
+
+ for line_num, line in f.ChangedContents():
+ if 'UNIT_TEST ' in line or line.endswith('UNIT_TEST'):
+ problems.append(' %s:%d' % (f.LocalPath(), line_num))
+
+ if not problems:
+ return []
+ return [output_api.PresubmitPromptWarning('UNIT_TEST is only for headers.\n' +
+ '\n'.join(problems))]
+
+
+def _CheckNoNewWStrings(input_api, output_api):
+ """Checks to make sure we don't introduce use of wstrings."""
+ problems = []
+ for f in input_api.AffectedFiles():
+ if (not f.LocalPath().endswith(('.cc', '.h')) or
+ f.LocalPath().endswith(('test.cc', '_win.cc', '_win.h'))):
+ continue
+
+ allowWString = False
+ for line_num, line in f.ChangedContents():
+ if 'presubmit: allow wstring' in line:
+ allowWString = True
+ elif not allowWString and 'wstring' in line:
+ problems.append(' %s:%d' % (f.LocalPath(), line_num))
+ allowWString = False
+ else:
+ allowWString = False
+
+ if not problems:
+ return []
+ return [output_api.PresubmitPromptWarning('New code should not use wstrings.'
+ ' If you are calling a cross-platform API that accepts a wstring, '
+ 'fix the API.\n' +
+ '\n'.join(problems))]
+
+
+def _CheckNoDEPSGIT(input_api, output_api):
+ """Make sure .DEPS.git is never modified manually."""
+ if any(f.LocalPath().endswith('.DEPS.git') for f in
+ input_api.AffectedFiles()):
+ return [output_api.PresubmitError(
+ 'Never commit changes to .DEPS.git. This file is maintained by an\n'
+ 'automated system based on what\'s in DEPS and your changes will be\n'
+ 'overwritten.\n'
+ 'See https://sites.google.com/a/chromium.org/dev/developers/how-tos/get-the-code#Rolling_DEPS\n'
+ 'for more information')]
+ return []
+
+
+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, error:
+ return [output_api.PresubmitError(
+ 'DEPS file must have only git dependencies.',
+ long_text=error.output)]
+
+
+def _CheckNoBannedFunctions(input_api, output_api):
+ """Make sure that banned functions are not used."""
+ warnings = []
+ errors = []
+
+ file_filter = lambda f: f.LocalPath().endswith(('.mm', '.m', '.h'))
+ for f in input_api.AffectedFiles(file_filter=file_filter):
+ for line_num, line in f.ChangedContents():
+ for func_name, message, error in _BANNED_OBJC_FUNCTIONS:
+ matched = False
+ if func_name[0:1] == '/':
+ regex = func_name[1:]
+ if input_api.re.search(regex, line):
+ matched = True
+ elif func_name in line:
+ matched = True
+ if matched:
+ problems = warnings;
+ if error:
+ problems = errors;
+ problems.append(' %s:%d:' % (f.LocalPath(), line_num))
+ for message_line in message:
+ problems.append(' %s' % message_line)
+
+ file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))
+ for f in input_api.AffectedFiles(file_filter=file_filter):
+ for line_num, line in f.ChangedContents():
+ for func_name, message, error, excluded_paths in _BANNED_CPP_FUNCTIONS:
+ def IsBlacklisted(affected_file, blacklist):
+ local_path = affected_file.LocalPath()
+ for item in blacklist:
+ if input_api.re.match(item, local_path):
+ return True
+ return False
+ if IsBlacklisted(f, excluded_paths):
+ continue
+ matched = False
+ if func_name[0:1] == '/':
+ regex = func_name[1:]
+ if input_api.re.search(regex, line):
+ matched = True
+ elif func_name in line:
+ matched = True
+ if matched:
+ problems = warnings;
+ if error:
+ problems = errors;
+ problems.append(' %s:%d:' % (f.LocalPath(), line_num))
+ for message_line in message:
+ problems.append(' %s' % message_line)
+
+ result = []
+ if (warnings):
+ result.append(output_api.PresubmitPromptWarning(
+ 'Banned functions were used.\n' + '\n'.join(warnings)))
+ if (errors):
+ result.append(output_api.PresubmitError(
+ 'Banned functions were used.\n' + '\n'.join(errors)))
+ return result
+
+
+def _CheckNoPragmaOnce(input_api, output_api):
+ """Make sure that banned functions are not used."""
+ files = []
+ pattern = input_api.re.compile(r'^#pragma\s+once',
+ input_api.re.MULTILINE)
+ for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
+ if not f.LocalPath().endswith('.h'):
+ continue
+ contents = input_api.ReadFile(f)
+ if pattern.search(contents):
+ files.append(f)
+
+ if files:
+ return [output_api.PresubmitError(
+ 'Do not use #pragma once in header files.\n'
+ 'See http://www.chromium.org/developers/coding-style#TOC-File-headers',
+ files)]
+ return []
+
+
+def _CheckNoTrinaryTrueFalse(input_api, output_api):
+ """Checks to make sure we don't introduce use of foo ? true : false."""
+ problems = []
+ pattern = input_api.re.compile(r'\?\s*(true|false)\s*:\s*(true|false)')
+ for f in input_api.AffectedFiles():
+ if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')):
+ continue
+
+ for line_num, line in f.ChangedContents():
+ if pattern.match(line):
+ problems.append(' %s:%d' % (f.LocalPath(), line_num))
+
+ if not problems:
+ return []
+ return [output_api.PresubmitPromptWarning(
+ 'Please consider avoiding the "? true : false" pattern if possible.\n' +
+ '\n'.join(problems))]
+
+
+def _CheckUnwantedDependencies(input_api, output_api):
+ """Runs checkdeps on #include statements added in this
+ change. Breaking - rules is an error, breaking ! rules is a
+ warning.
+ """
+ # We need to wait until we have an input_api object and use this
+ # roundabout construct to import checkdeps because this file is
+ # eval-ed and thus doesn't have __file__.
+ original_sys_path = sys.path
+ try:
+ sys.path = sys.path + [input_api.os_path.join(
+ input_api.PresubmitLocalPath(), 'buildtools', 'checkdeps')]
+ import checkdeps
+ from cpp_checker import CppChecker
+ from rules import Rule
+ finally:
+ # Restore sys.path to what it was before.
+ sys.path = original_sys_path
+
+ added_includes = []
+ for f in input_api.AffectedFiles():
+ if not CppChecker.IsCppFile(f.LocalPath()):
+ continue
+
+ changed_lines = [line for line_num, line in f.ChangedContents()]
+ added_includes.append([f.LocalPath(), changed_lines])
+
+ deps_checker = checkdeps.DepsChecker(input_api.PresubmitLocalPath())
+
+ error_descriptions = []
+ warning_descriptions = []
+ for path, rule_type, rule_description in deps_checker.CheckAddedCppIncludes(
+ added_includes):
+ description_with_path = '%s\n %s' % (path, rule_description)
+ if rule_type == Rule.DISALLOW:
+ error_descriptions.append(description_with_path)
+ else:
+ warning_descriptions.append(description_with_path)
+
+ results = []
+ if error_descriptions:
+ results.append(output_api.PresubmitError(
+ 'You added one or more #includes that violate checkdeps rules.',
+ error_descriptions))
+ if warning_descriptions:
+ results.append(output_api.PresubmitPromptOrNotify(
+ 'You added one or more #includes of files that are temporarily\n'
+ 'allowed but being removed. Can you avoid introducing the\n'
+ '#include? See relevant DEPS file(s) for details and contacts.',
+ warning_descriptions))
+ return results
+
+
+def _CheckFilePermissions(input_api, output_api):
+ """Check that all files have their permissions properly set."""
+ if input_api.platform == 'win32':
+ return []
+ args = [sys.executable, 'tools/checkperms/checkperms.py', '--root',
+ input_api.change.RepositoryRoot()]
+ for f in input_api.AffectedFiles():
+ args += ['--file', f.LocalPath()]
+ checkperms = input_api.subprocess.Popen(args,
+ stdout=input_api.subprocess.PIPE)
+ errors = checkperms.communicate()[0].strip()
+ if errors:
+ return [output_api.PresubmitError('checkperms.py failed.',
+ errors.splitlines())]
+ return []
+
+
+def _CheckNoAuraWindowPropertyHInHeaders(input_api, output_api):
+ """Makes sure we don't include ui/aura/window_property.h
+ in header files.
+ """
+ pattern = input_api.re.compile(r'^#include\s*"ui/aura/window_property.h"')
+ errors = []
+ for f in input_api.AffectedFiles():
+ if not f.LocalPath().endswith('.h'):
+ continue
+ for line_num, line in f.ChangedContents():
+ if pattern.match(line):
+ errors.append(' %s:%d' % (f.LocalPath(), line_num))
+
+ results = []
+ if errors:
+ results.append(output_api.PresubmitError(
+ 'Header files should not include ui/aura/window_property.h', errors))
+ return results
+
+
+def _CheckIncludeOrderForScope(scope, input_api, file_path, changed_linenums):
+ """Checks that the lines in scope occur in the right order.
+
+ 1. C system files in alphabetical order
+ 2. C++ system files in alphabetical order
+ 3. Project's .h files
+ """
+
+ c_system_include_pattern = input_api.re.compile(r'\s*#include <.*\.h>')
+ cpp_system_include_pattern = input_api.re.compile(r'\s*#include <.*>')
+ custom_include_pattern = input_api.re.compile(r'\s*#include ".*')
+
+ C_SYSTEM_INCLUDES, CPP_SYSTEM_INCLUDES, CUSTOM_INCLUDES = range(3)
+
+ state = C_SYSTEM_INCLUDES
+
+ previous_line = ''
+ previous_line_num = 0
+ problem_linenums = []
+ for line_num, line in scope:
+ if c_system_include_pattern.match(line):
+ if state != C_SYSTEM_INCLUDES:
+ problem_linenums.append((line_num, previous_line_num))
+ elif previous_line and previous_line > line:
+ problem_linenums.append((line_num, previous_line_num))
+ elif cpp_system_include_pattern.match(line):
+ if state == C_SYSTEM_INCLUDES:
+ state = CPP_SYSTEM_INCLUDES
+ elif state == CUSTOM_INCLUDES:
+ problem_linenums.append((line_num, previous_line_num))
+ elif previous_line and previous_line > line:
+ problem_linenums.append((line_num, previous_line_num))
+ elif custom_include_pattern.match(line):
+ if state != CUSTOM_INCLUDES:
+ state = CUSTOM_INCLUDES
+ elif previous_line and previous_line > line:
+ problem_linenums.append((line_num, previous_line_num))
+ else:
+ problem_linenums.append(line_num)
+ previous_line = line
+ previous_line_num = line_num
+
+ warnings = []
+ for (line_num, previous_line_num) in problem_linenums:
+ if line_num in changed_linenums or previous_line_num in changed_linenums:
+ warnings.append(' %s:%d' % (file_path, line_num))
+ return warnings
+
+
+def _CheckIncludeOrderInFile(input_api, f, changed_linenums):
+ """Checks the #include order for the given file f."""
+
+ system_include_pattern = input_api.re.compile(r'\s*#include \<.*')
+ # Exclude the following includes from the check:
+ # 1) #include <.../...>, e.g., <sys/...> includes often need to appear in a
+ # specific order.
+ # 2) <atlbase.h>, "build/build_config.h"
+ excluded_include_pattern = input_api.re.compile(
+ r'\s*#include (\<.*/.*|\<atlbase\.h\>|"build/build_config.h")')
+ custom_include_pattern = input_api.re.compile(r'\s*#include "(?P<FILE>.*)"')
+ # Match the final or penultimate token if it is xxxtest so we can ignore it
+ # when considering the special first include.
+ test_file_tag_pattern = input_api.re.compile(
+ r'_[a-z]+test(?=(_[a-zA-Z0-9]+)?\.)')
+ if_pattern = input_api.re.compile(
+ r'\s*#\s*(if|elif|else|endif|define|undef).*')
+ # Some files need specialized order of includes; exclude such files from this
+ # check.
+ uncheckable_includes_pattern = input_api.re.compile(
+ r'\s*#include '
+ '("ipc/.*macros\.h"|<windows\.h>|".*gl.*autogen.h")\s*')
+
+ contents = f.NewContents()
+ warnings = []
+ line_num = 0
+
+ # Handle the special first include. If the first include file is
+ # some/path/file.h, the corresponding including file can be some/path/file.cc,
+ # some/other/path/file.cc, some/path/file_platform.cc, some/path/file-suffix.h
+ # etc. It's also possible that no special first include exists.
+ # If the included file is some/path/file_platform.h the including file could
+ # also be some/path/file_xxxtest_platform.h.
+ including_file_base_name = test_file_tag_pattern.sub(
+ '', input_api.os_path.basename(f.LocalPath()))
+
+ for line in contents:
+ line_num += 1
+ if system_include_pattern.match(line):
+ # No special first include -> process the line again along with normal
+ # includes.
+ line_num -= 1
+ break
+ match = custom_include_pattern.match(line)
+ if match:
+ match_dict = match.groupdict()
+ header_basename = test_file_tag_pattern.sub(
+ '', input_api.os_path.basename(match_dict['FILE'])).replace('.h', '')
+
+ if header_basename not in including_file_base_name:
+ # No special first include -> process the line again along with normal
+ # includes.
+ line_num -= 1
+ break
+
+ # Split into scopes: Each region between #if and #endif is its own scope.
+ scopes = []
+ current_scope = []
+ for line in contents[line_num:]:
+ line_num += 1
+ if uncheckable_includes_pattern.match(line):
+ continue
+ if if_pattern.match(line):
+ scopes.append(current_scope)
+ current_scope = []
+ elif ((system_include_pattern.match(line) or
+ custom_include_pattern.match(line)) and
+ not excluded_include_pattern.match(line)):
+ current_scope.append((line_num, line))
+ scopes.append(current_scope)
+
+ for scope in scopes:
+ warnings.extend(_CheckIncludeOrderForScope(scope, input_api, f.LocalPath(),
+ changed_linenums))
+ return warnings
+
+
+def _CheckIncludeOrder(input_api, output_api):
+ """Checks that the #include order is correct.
+
+ 1. The corresponding header for source files.
+ 2. C system files in alphabetical order
+ 3. C++ system files in alphabetical order
+ 4. Project's .h files in alphabetical order
+
+ Each region separated by #if, #elif, #else, #endif, #define and #undef follows
+ these rules separately.
+ """
+ def FileFilterIncludeOrder(affected_file):
+ black_list = (_EXCLUDED_PATHS + input_api.DEFAULT_BLACK_LIST)
+ return input_api.FilterSourceFile(affected_file, black_list=black_list)
+
+ warnings = []
+ for f in input_api.AffectedFiles(file_filter=FileFilterIncludeOrder):
+ if f.LocalPath().endswith(('.cc', '.h')):
+ changed_linenums = set(line_num for line_num, _ in f.ChangedContents())
+ warnings.extend(_CheckIncludeOrderInFile(input_api, f, changed_linenums))
+
+ results = []
+ if warnings:
+ results.append(output_api.PresubmitPromptOrNotify(_INCLUDE_ORDER_WARNING,
+ warnings))
+ return results
+
+
+def _CheckForVersionControlConflictsInFile(input_api, f):
+ pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$')
+ errors = []
+ for line_num, line in f.ChangedContents():
+ if pattern.match(line):
+ errors.append(' %s:%d %s' % (f.LocalPath(), line_num, line))
+ return errors
+
+
+def _CheckForVersionControlConflicts(input_api, output_api):
+ """Usually this is not intentional and will cause a compile failure."""
+ errors = []
+ for f in input_api.AffectedFiles():
+ errors.extend(_CheckForVersionControlConflictsInFile(input_api, f))
+
+ results = []
+ if errors:
+ results.append(output_api.PresubmitError(
+ 'Version control conflict markers found, please resolve.', errors))
+ return results
+
+
+def _CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api):
+ def FilterFile(affected_file):
+ """Filter function for use with input_api.AffectedSourceFiles,
+ below. This filters out everything except non-test files from
+ top-level directories that generally speaking should not hard-code
+ service URLs (e.g. src/android_webview/, src/content/ and others).
+ """
+ return input_api.FilterSourceFile(
+ affected_file,
+ white_list=(r'^(android_webview|base|content|net)[\\\/].*', ),
+ black_list=(_EXCLUDED_PATHS +
+ _TEST_CODE_EXCLUDED_PATHS +
+ input_api.DEFAULT_BLACK_LIST))
+
+ base_pattern = '"[^"]*google\.com[^"]*"'
+ comment_pattern = input_api.re.compile('//.*%s' % base_pattern)
+ pattern = input_api.re.compile(base_pattern)
+ problems = [] # items are (filename, line_number, line)
+ for f in input_api.AffectedSourceFiles(FilterFile):
+ for line_num, line in f.ChangedContents():
+ if not comment_pattern.search(line) and pattern.search(line):
+ problems.append((f.LocalPath(), line_num, line))
+
+ if problems:
+ return [output_api.PresubmitPromptOrNotify(
+ 'Most layers below src/chrome/ should not hardcode service URLs.\n'
+ 'Are you sure this is correct?',
+ [' %s:%d: %s' % (
+ problem[0], problem[1], problem[2]) for problem in problems])]
+ else:
+ return []
+
+
+def _CheckNoAbbreviationInPngFileName(input_api, output_api):
+ """Makes sure there are no abbreviations in the name of PNG files.
+ """
+ pattern = input_api.re.compile(r'.*_[a-z]_.*\.png$|.*_[a-z]\.png$')
+ errors = []
+ for f in input_api.AffectedFiles(include_deletes=False):
+ if pattern.match(f.LocalPath()):
+ errors.append(' %s' % f.LocalPath())
+
+ results = []
+ if errors:
+ results.append(output_api.PresubmitError(
+ 'The name of PNG files should not have abbreviations. \n'
+ 'Use _hover.png, _center.png, instead of _h.png, _c.png.\n'
+ 'Contact oshima@chromium.org if you have questions.', errors))
+ return results
+
+
+def _FilesToCheckForIncomingDeps(re, changed_lines):
+ """Helper method for _CheckAddedDepsHaveTargetApprovals. Returns
+ a set of DEPS entries that we should look up.
+
+ For a directory (rather than a specific filename) we fake a path to
+ a specific filename by adding /DEPS. This is chosen as a file that
+ will seldom or never be subject to per-file include_rules.
+ """
+ # We ignore deps entries on auto-generated directories.
+ AUTO_GENERATED_DIRS = ['grit', 'jni']
+
+ # This pattern grabs the path without basename in the first
+ # parentheses, and the basename (if present) in the second. It
+ # relies on the simple heuristic that if there is a basename it will
+ # be a header file ending in ".h".
+ pattern = re.compile(
+ r"""['"]\+([^'"]+?)(/[a-zA-Z0-9_]+\.h)?['"].*""")
+ results = set()
+ for changed_line in changed_lines:
+ m = pattern.match(changed_line)
+ if m:
+ path = m.group(1)
+ if path.split('/')[0] not in AUTO_GENERATED_DIRS:
+ if m.group(2):
+ results.add('%s%s' % (path, m.group(2)))
+ else:
+ results.add('%s/DEPS' % path)
+ return results
+
+
+def _CheckAddedDepsHaveTargetApprovals(input_api, output_api):
+ """When a dependency prefixed with + is added to a DEPS file, we
+ want to make sure that the change is reviewed by an OWNER of the
+ target file or directory, to avoid layering violations from being
+ introduced. This check verifies that this happens.
+ """
+ changed_lines = set()
+ for f in input_api.AffectedFiles():
+ filename = input_api.os_path.basename(f.LocalPath())
+ if filename == 'DEPS':
+ changed_lines |= set(line.strip()
+ for line_num, line
+ in f.ChangedContents())
+ if not changed_lines:
+ return []
+
+ virtual_depended_on_files = _FilesToCheckForIncomingDeps(input_api.re,
+ changed_lines)
+ if not virtual_depended_on_files:
+ return []
+
+ if input_api.is_committing:
+ if input_api.tbr:
+ return [output_api.PresubmitNotifyResult(
+ '--tbr was specified, skipping OWNERS check for DEPS additions')]
+ if not input_api.change.issue:
+ return [output_api.PresubmitError(
+ "DEPS approval by OWNERS check failed: this change has "
+ "no Rietveld issue number, so we can't check it for approvals.")]
+ output = output_api.PresubmitError
+ else:
+ output = output_api.PresubmitNotifyResult
+
+ owners_db = input_api.owners_db
+ owner_email, reviewers = input_api.canned_checks._RietveldOwnerAndReviewers(
+ input_api,
+ owners_db.email_regexp,
+ approval_needed=input_api.is_committing)
+
+ owner_email = owner_email or input_api.change.author_email
+
+ reviewers_plus_owner = set(reviewers)
+ if owner_email:
+ reviewers_plus_owner.add(owner_email)
+ missing_files = owners_db.files_not_covered_by(virtual_depended_on_files,
+ reviewers_plus_owner)
+
+ # We strip the /DEPS part that was added by
+ # _FilesToCheckForIncomingDeps to fake a path to a file in a
+ # directory.
+ def StripDeps(path):
+ start_deps = path.rfind('/DEPS')
+ if start_deps != -1:
+ return path[:start_deps]
+ else:
+ return path
+ unapproved_dependencies = ["'+%s'," % StripDeps(path)
+ for path in missing_files]
+
+ if unapproved_dependencies:
+ output_list = [
+ output('Missing LGTM from OWNERS of dependencies added to DEPS:\n %s' %
+ '\n '.join(sorted(unapproved_dependencies)))]
+ if not input_api.is_committing:
+ suggested_owners = owners_db.reviewers_for(missing_files, owner_email)
+ output_list.append(output(
+ 'Suggested missing target path OWNERS:\n %s' %
+ '\n '.join(suggested_owners or [])))
+ return output_list
+
+ return []
+
+
+def _CheckSpamLogging(input_api, output_api):
+ file_inclusion_pattern = r'.+%s' % _IMPLEMENTATION_EXTENSIONS
+ black_list = (_EXCLUDED_PATHS +
+ _TEST_CODE_EXCLUDED_PATHS +
+ input_api.DEFAULT_BLACK_LIST +
+ (r"^base[\\\/]logging\.h$",
+ r"^base[\\\/]logging\.cc$",
+ r"^chrome[\\\/]app[\\\/]chrome_main_delegate\.cc$",
+ r"^chrome[\\\/]browser[\\\/]chrome_browser_main\.cc$",
+ r"^chrome[\\\/]browser[\\\/]ui[\\\/]startup[\\\/]"
+ r"startup_browser_creator\.cc$",
+ r"^chrome[\\\/]installer[\\\/]setup[\\\/].*",
+ r"chrome[\\\/]browser[\\\/]diagnostics[\\\/]" +
+ r"diagnostics_writer\.cc$",
+ r"^chrome_elf[\\\/]dll_hash[\\\/]dll_hash_main\.cc$",
+ r"^chromecast[\\\/]",
+ r"^cloud_print[\\\/]",
+ r"^content[\\\/]common[\\\/]gpu[\\\/]client[\\\/]"
+ r"gl_helper_benchmark\.cc$",
+ r"^courgette[\\\/]courgette_tool\.cc$",
+ r"^extensions[\\\/]renderer[\\\/]logging_native_handler\.cc$",
+ r"^native_client_sdk[\\\/]",
+ r"^remoting[\\\/]base[\\\/]logging\.h$",
+ r"^remoting[\\\/]host[\\\/].*",
+ r"^sandbox[\\\/]linux[\\\/].*",
+ r"^tools[\\\/]",
+ r"^ui[\\\/]aura[\\\/]bench[\\\/]bench_main\.cc$",
+ r"^webkit[\\\/]browser[\\\/]fileapi[\\\/]" +
+ r"dump_file_system.cc$",))
+ source_file_filter = lambda x: input_api.FilterSourceFile(
+ x, white_list=(file_inclusion_pattern,), black_list=black_list)
+
+ log_info = []
+ printf = []
+
+ for f in input_api.AffectedSourceFiles(source_file_filter):
+ contents = input_api.ReadFile(f, 'rb')
+ if re.search(r"\bD?LOG\s*\(\s*INFO\s*\)", contents):
+ log_info.append(f.LocalPath())
+ elif re.search(r"\bD?LOG_IF\s*\(\s*INFO\s*,", contents):
+ log_info.append(f.LocalPath())
+
+ if re.search(r"\bprintf\(", contents):
+ printf.append(f.LocalPath())
+ elif re.search(r"\bfprintf\((stdout|stderr)", contents):
+ printf.append(f.LocalPath())
+
+ if log_info:
+ return [output_api.PresubmitError(
+ 'These files spam the console log with LOG(INFO):',
+ items=log_info)]
+ if printf:
+ return [output_api.PresubmitError(
+ 'These files spam the console log with printf/fprintf:',
+ items=printf)]
+ return []
+
+
+def _CheckForAnonymousVariables(input_api, output_api):
+ """These types are all expected to hold locks while in scope and
+ so should never be anonymous (which causes them to be immediately
+ destroyed)."""
+ they_who_must_be_named = [
+ 'base::AutoLock',
+ 'base::AutoReset',
+ 'base::AutoUnlock',
+ 'SkAutoAlphaRestore',
+ 'SkAutoBitmapShaderInstall',
+ 'SkAutoBlitterChoose',
+ 'SkAutoBounderCommit',
+ 'SkAutoCallProc',
+ 'SkAutoCanvasRestore',
+ 'SkAutoCommentBlock',
+ 'SkAutoDescriptor',
+ 'SkAutoDisableDirectionCheck',
+ 'SkAutoDisableOvalCheck',
+ 'SkAutoFree',
+ 'SkAutoGlyphCache',
+ 'SkAutoHDC',
+ 'SkAutoLockColors',
+ 'SkAutoLockPixels',
+ 'SkAutoMalloc',
+ 'SkAutoMaskFreeImage',
+ 'SkAutoMutexAcquire',
+ 'SkAutoPathBoundsUpdate',
+ 'SkAutoPDFRelease',
+ 'SkAutoRasterClipValidate',
+ 'SkAutoRef',
+ 'SkAutoTime',
+ 'SkAutoTrace',
+ 'SkAutoUnref',
+ ]
+ anonymous = r'(%s)\s*[({]' % '|'.join(they_who_must_be_named)
+ # bad: base::AutoLock(lock.get());
+ # not bad: base::AutoLock lock(lock.get());
+ bad_pattern = input_api.re.compile(anonymous)
+ # good: new base::AutoLock(lock.get())
+ good_pattern = input_api.re.compile(r'\bnew\s*' + anonymous)
+ errors = []
+
+ for f in input_api.AffectedFiles():
+ if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')):
+ continue
+ for linenum, line in f.ChangedContents():
+ if bad_pattern.search(line) and not good_pattern.search(line):
+ errors.append('%s:%d' % (f.LocalPath(), linenum))
+
+ if errors:
+ return [output_api.PresubmitError(
+ 'These lines create anonymous variables that need to be named:',
+ items=errors)]
+ return []
+
+
+def _CheckCygwinShell(input_api, output_api):
+ source_file_filter = lambda x: input_api.FilterSourceFile(
+ x, white_list=(r'.+\.(gyp|gypi)$',))
+ cygwin_shell = []
+
+ for f in input_api.AffectedSourceFiles(source_file_filter):
+ for linenum, line in f.ChangedContents():
+ if 'msvs_cygwin_shell' in line:
+ cygwin_shell.append(f.LocalPath())
+ break
+
+ if cygwin_shell:
+ return [output_api.PresubmitError(
+ 'These files should not use msvs_cygwin_shell (the default is 0):',
+ items=cygwin_shell)]
+ return []
+
+
+def _CheckUserActionUpdate(input_api, output_api):
+ """Checks if any new user action has been added."""
+ if any('actions.xml' == input_api.os_path.basename(f) for f in
+ input_api.LocalPaths()):
+ # If actions.xml is already included in the changelist, the PRESUBMIT
+ # for actions.xml will do a more complete presubmit check.
+ return []
+
+ file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm'))
+ action_re = r'[^a-zA-Z]UserMetricsAction\("([^"]*)'
+ current_actions = None
+ for f in input_api.AffectedFiles(file_filter=file_filter):
+ for line_num, line in f.ChangedContents():
+ match = input_api.re.search(action_re, line)
+ if match:
+ # Loads contents in tools/metrics/actions/actions.xml to memory. It's
+ # loaded only once.
+ if not current_actions:
+ with open('tools/metrics/actions/actions.xml') as actions_f:
+ current_actions = actions_f.read()
+ # Search for the matched user action name in |current_actions|.
+ for action_name in match.groups():
+ action = 'name="{0}"'.format(action_name)
+ if action not in current_actions:
+ return [output_api.PresubmitPromptWarning(
+ 'File %s line %d: %s is missing in '
+ 'tools/metrics/actions/actions.xml. Please run '
+ 'tools/metrics/actions/extract_actions.py to update.'
+ % (f.LocalPath(), line_num, action_name))]
+ return []
+
+
+def _GetJSONParseError(input_api, filename, eat_comments=True):
+ try:
+ contents = input_api.ReadFile(filename)
+ if eat_comments:
+ json_comment_eater = input_api.os_path.join(
+ input_api.PresubmitLocalPath(),
+ 'tools', 'json_comment_eater', 'json_comment_eater.py')
+ process = input_api.subprocess.Popen(
+ [input_api.python_executable, json_comment_eater],
+ stdin=input_api.subprocess.PIPE,
+ stdout=input_api.subprocess.PIPE,
+ universal_newlines=True)
+ (contents, _) = process.communicate(input=contents)
+
+ input_api.json.loads(contents)
+ except ValueError as e:
+ return e
+ return None
+
+
+def _GetIDLParseError(input_api, filename):
+ try:
+ contents = input_api.ReadFile(filename)
+ idl_schema = input_api.os_path.join(
+ input_api.PresubmitLocalPath(),
+ 'tools', 'json_schema_compiler', 'idl_schema.py')
+ process = input_api.subprocess.Popen(
+ [input_api.python_executable, idl_schema],
+ stdin=input_api.subprocess.PIPE,
+ stdout=input_api.subprocess.PIPE,
+ stderr=input_api.subprocess.PIPE,
+ universal_newlines=True)
+ (_, error) = process.communicate(input=contents)
+ return error or None
+ except ValueError as e:
+ return e
+
+
+def _CheckParseErrors(input_api, output_api):
+ """Check that IDL and JSON files do not contain syntax errors."""
+ actions = {
+ '.idl': _GetIDLParseError,
+ '.json': _GetJSONParseError,
+ }
+ # These paths contain test data and other known invalid JSON files.
+ excluded_patterns = [
+ r'test[\\\/]data[\\\/]',
+ r'^components[\\\/]policy[\\\/]resources[\\\/]policy_templates\.json$',
+ ]
+ # Most JSON files are preprocessed and support comments, but these do not.
+ json_no_comments_patterns = [
+ r'^testing[\\\/]',
+ ]
+ # Only run IDL checker on files in these directories.
+ idl_included_patterns = [
+ r'^chrome[\\\/]common[\\\/]extensions[\\\/]api[\\\/]',
+ r'^extensions[\\\/]common[\\\/]api[\\\/]',
+ ]
+
+ def get_action(affected_file):
+ filename = affected_file.LocalPath()
+ return actions.get(input_api.os_path.splitext(filename)[1])
+
+ def MatchesFile(patterns, path):
+ for pattern in patterns:
+ if input_api.re.search(pattern, path):
+ return True
+ return False
+
+ def FilterFile(affected_file):
+ action = get_action(affected_file)
+ if not action:
+ return False
+ path = affected_file.LocalPath()
+
+ if MatchesFile(excluded_patterns, path):
+ return False
+
+ if (action == _GetIDLParseError and
+ not MatchesFile(idl_included_patterns, path)):
+ return False
+ return True
+
+ results = []
+ for affected_file in input_api.AffectedFiles(
+ file_filter=FilterFile, include_deletes=False):
+ action = get_action(affected_file)
+ kwargs = {}
+ if (action == _GetJSONParseError and
+ MatchesFile(json_no_comments_patterns, affected_file.LocalPath())):
+ kwargs['eat_comments'] = False
+ parse_error = action(input_api,
+ affected_file.AbsoluteLocalPath(),
+ **kwargs)
+ if parse_error:
+ results.append(output_api.PresubmitError('%s could not be parsed: %s' %
+ (affected_file.LocalPath(), parse_error)))
+ return results
+
+
+def _CheckJavaStyle(input_api, output_api):
+ """Runs checkstyle on changed java files and returns errors if any exist."""
+ original_sys_path = sys.path
+ try:
+ sys.path = sys.path + [input_api.os_path.join(
+ input_api.PresubmitLocalPath(), 'tools', 'android', 'checkstyle')]
+ import checkstyle
+ finally:
+ # Restore sys.path to what it was before.
+ sys.path = original_sys_path
+
+ return checkstyle.RunCheckstyle(
+ input_api, output_api, 'tools/android/checkstyle/chromium-style-5.0.xml')
+
+
+_DEPRECATED_CSS = [
+ # Values
+ ( "-webkit-box", "flex" ),
+ ( "-webkit-inline-box", "inline-flex" ),
+ ( "-webkit-flex", "flex" ),
+ ( "-webkit-inline-flex", "inline-flex" ),
+ ( "-webkit-min-content", "min-content" ),
+ ( "-webkit-max-content", "max-content" ),
+
+ # Properties
+ ( "-webkit-background-clip", "background-clip" ),
+ ( "-webkit-background-origin", "background-origin" ),
+ ( "-webkit-background-size", "background-size" ),
+ ( "-webkit-box-shadow", "box-shadow" ),
+
+ # Functions
+ ( "-webkit-gradient", "gradient" ),
+ ( "-webkit-repeating-gradient", "repeating-gradient" ),
+ ( "-webkit-linear-gradient", "linear-gradient" ),
+ ( "-webkit-repeating-linear-gradient", "repeating-linear-gradient" ),
+ ( "-webkit-radial-gradient", "radial-gradient" ),
+ ( "-webkit-repeating-radial-gradient", "repeating-radial-gradient" ),
+]
+
+def _CheckNoDeprecatedCSS(input_api, output_api):
+ """ Make sure that we don't use deprecated CSS
+ properties, functions or values. Our external
+ documentation is ignored by the hooks as it
+ needs to be consumed by WebKit. """
+ results = []
+ file_inclusion_pattern = (r".+\.css$")
+ black_list = (_EXCLUDED_PATHS +
+ _TEST_CODE_EXCLUDED_PATHS +
+ input_api.DEFAULT_BLACK_LIST +
+ (r"^chrome/common/extensions/docs",
+ r"^chrome/docs",
+ r"^native_client_sdk"))
+ file_filter = lambda f: input_api.FilterSourceFile(
+ f, white_list=file_inclusion_pattern, black_list=black_list)
+ for fpath in input_api.AffectedFiles(file_filter=file_filter):
+ for line_num, line in fpath.ChangedContents():
+ for (deprecated_value, value) in _DEPRECATED_CSS:
+ if input_api.re.search(deprecated_value, line):
+ results.append(output_api.PresubmitError(
+ "%s:%d: Use of deprecated CSS %s, use %s instead" %
+ (fpath.LocalPath(), line_num, deprecated_value, value)))
+ return results
+
+def _CommonChecks(input_api, output_api):
+ """Checks common to both upload and commit."""
+ results = []
+ results.extend(input_api.canned_checks.PanProjectChecks(
+ input_api, output_api,
+ excluded_paths=_EXCLUDED_PATHS + _TESTRUNNER_PATHS))
+ results.extend(_CheckAuthorizedAuthor(input_api, output_api))
+ results.extend(
+ _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api))
+ results.extend(_CheckNoIOStreamInHeaders(input_api, output_api))
+ results.extend(_CheckNoUNIT_TESTInSourceFiles(input_api, output_api))
+ results.extend(_CheckNoNewWStrings(input_api, output_api))
+ results.extend(_CheckNoDEPSGIT(input_api, output_api))
+ results.extend(_CheckNoBannedFunctions(input_api, output_api))
+ results.extend(_CheckNoPragmaOnce(input_api, output_api))
+ results.extend(_CheckNoTrinaryTrueFalse(input_api, output_api))
+ results.extend(_CheckUnwantedDependencies(input_api, output_api))
+ results.extend(_CheckFilePermissions(input_api, output_api))
+ results.extend(_CheckNoAuraWindowPropertyHInHeaders(input_api, output_api))
+ results.extend(_CheckIncludeOrder(input_api, output_api))
+ results.extend(_CheckForVersionControlConflicts(input_api, output_api))
+ results.extend(_CheckPatchFiles(input_api, output_api))
+ results.extend(_CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api))
+ results.extend(_CheckNoAbbreviationInPngFileName(input_api, output_api))
+ results.extend(_CheckForInvalidOSMacros(input_api, output_api))
+ results.extend(_CheckForInvalidIfDefinedMacros(input_api, output_api))
+ results.extend(_CheckAddedDepsHaveTargetApprovals(input_api, output_api))
+ results.extend(
+ input_api.canned_checks.CheckChangeHasNoTabs(
+ input_api,
+ output_api,
+ source_file_filter=lambda x: x.LocalPath().endswith('.grd')))
+ results.extend(_CheckSpamLogging(input_api, output_api))
+ results.extend(_CheckForAnonymousVariables(input_api, output_api))
+ results.extend(_CheckCygwinShell(input_api, output_api))
+ results.extend(_CheckUserActionUpdate(input_api, output_api))
+ results.extend(_CheckNoDeprecatedCSS(input_api, output_api))
+ results.extend(_CheckParseErrors(input_api, output_api))
+ results.extend(_CheckForIPCRules(input_api, output_api))
+
+ if any('PRESUBMIT.py' == f.LocalPath() for f in input_api.AffectedFiles()):
+ results.extend(input_api.canned_checks.RunUnitTestsInDirectory(
+ input_api, output_api,
+ input_api.PresubmitLocalPath(),
+ whitelist=[r'^PRESUBMIT_test\.py$']))
+ return results
+
+
+def _CheckAuthorizedAuthor(input_api, output_api):
+ """For non-googler/chromites committers, verify the author's email address is
+ in AUTHORS.
+ """
+ # TODO(maruel): Add it to input_api?
+ import fnmatch
+
+ author = input_api.change.author_email
+ if not author:
+ input_api.logging.info('No author, skipping AUTHOR check')
+ return []
+ authors_path = input_api.os_path.join(
+ input_api.PresubmitLocalPath(), 'AUTHORS')
+ valid_authors = (
+ input_api.re.match(r'[^#]+\s+\<(.+?)\>\s*$', line)
+ for line in open(authors_path))
+ valid_authors = [item.group(1).lower() for item in valid_authors if item]
+ if not any(fnmatch.fnmatch(author.lower(), valid) for valid in valid_authors):
+ input_api.logging.info('Valid authors are %s', ', '.join(valid_authors))
+ return [output_api.PresubmitPromptWarning(
+ ('%s is not in AUTHORS file. If you are a new contributor, please visit'
+ '\n'
+ 'http://www.chromium.org/developers/contributing-code and read the '
+ '"Legal" section\n'
+ 'If you are a chromite, verify the contributor signed the CLA.') %
+ author)]
+ return []
+
+
+def _CheckPatchFiles(input_api, output_api):
+ problems = [f.LocalPath() for f in input_api.AffectedFiles()
+ if f.LocalPath().endswith(('.orig', '.rej'))]
+ if problems:
+ return [output_api.PresubmitError(
+ "Don't commit .rej and .orig files.", problems)]
+ else:
+ return []
+
+
+def _DidYouMeanOSMacro(bad_macro):
+ try:
+ return {'A': 'OS_ANDROID',
+ 'B': 'OS_BSD',
+ 'C': 'OS_CHROMEOS',
+ 'F': 'OS_FREEBSD',
+ 'L': 'OS_LINUX',
+ 'M': 'OS_MACOSX',
+ 'N': 'OS_NACL',
+ 'O': 'OS_OPENBSD',
+ 'P': 'OS_POSIX',
+ 'S': 'OS_SOLARIS',
+ 'W': 'OS_WIN'}[bad_macro[3].upper()]
+ except KeyError:
+ return ''
+
+
+def _CheckForInvalidOSMacrosInFile(input_api, f):
+ """Check for sensible looking, totally invalid OS macros."""
+ preprocessor_statement = input_api.re.compile(r'^\s*#')
+ os_macro = input_api.re.compile(r'defined\((OS_[^)]+)\)')
+ results = []
+ for lnum, line in f.ChangedContents():
+ if preprocessor_statement.search(line):
+ for match in os_macro.finditer(line):
+ if not match.group(1) in _VALID_OS_MACROS:
+ good = _DidYouMeanOSMacro(match.group(1))
+ did_you_mean = ' (did you mean %s?)' % good if good else ''
+ results.append(' %s:%d %s%s' % (f.LocalPath(),
+ lnum,
+ match.group(1),
+ did_you_mean))
+ return results
+
+
+def _CheckForInvalidOSMacros(input_api, output_api):
+ """Check all affected files for invalid OS macros."""
+ bad_macros = []
+ for f in input_api.AffectedFiles():
+ if not f.LocalPath().endswith(('.py', '.js', '.html', '.css')):
+ bad_macros.extend(_CheckForInvalidOSMacrosInFile(input_api, f))
+
+ if not bad_macros:
+ return []
+
+ return [output_api.PresubmitError(
+ 'Possibly invalid OS macro[s] found. Please fix your code\n'
+ 'or add your macro to src/PRESUBMIT.py.', bad_macros)]
+
+
+def _CheckForInvalidIfDefinedMacrosInFile(input_api, f):
+ """Check all affected files for invalid "if defined" macros."""
+ ALWAYS_DEFINED_MACROS = (
+ "TARGET_CPU_PPC",
+ "TARGET_CPU_PPC64",
+ "TARGET_CPU_68K",
+ "TARGET_CPU_X86",
+ "TARGET_CPU_ARM",
+ "TARGET_CPU_MIPS",
+ "TARGET_CPU_SPARC",
+ "TARGET_CPU_ALPHA",
+ "TARGET_IPHONE_SIMULATOR",
+ "TARGET_OS_EMBEDDED",
+ "TARGET_OS_IPHONE",
+ "TARGET_OS_MAC",
+ "TARGET_OS_UNIX",
+ "TARGET_OS_WIN32",
+ )
+ ifdef_macro = input_api.re.compile(r'^\s*#.*(?:ifdef\s|defined\()([^\s\)]+)')
+ results = []
+ for lnum, line in f.ChangedContents():
+ for match in ifdef_macro.finditer(line):
+ if match.group(1) in ALWAYS_DEFINED_MACROS:
+ always_defined = ' %s is always defined. ' % match.group(1)
+ did_you_mean = 'Did you mean \'#if %s\'?' % match.group(1)
+ results.append(' %s:%d %s\n\t%s' % (f.LocalPath(),
+ lnum,
+ always_defined,
+ did_you_mean))
+ return results
+
+
+def _CheckForInvalidIfDefinedMacros(input_api, output_api):
+ """Check all affected files for invalid "if defined" macros."""
+ bad_macros = []
+ for f in input_api.AffectedFiles():
+ if f.LocalPath().endswith(('.h', '.c', '.cc', '.m', '.mm')):
+ bad_macros.extend(_CheckForInvalidIfDefinedMacrosInFile(input_api, f))
+
+ if not bad_macros:
+ return []
+
+ return [output_api.PresubmitError(
+ 'Found ifdef check on always-defined macro[s]. Please fix your code\n'
+ 'or check the list of ALWAYS_DEFINED_MACROS in src/PRESUBMIT.py.',
+ bad_macros)]
+
+
+def _CheckForIPCRules(input_api, output_api):
+ """Check for same IPC rules described in
+ http://www.chromium.org/Home/chromium-security/education/security-tips-for-ipc
+ """
+ base_pattern = r'IPC_ENUM_TRAITS\('
+ inclusion_pattern = input_api.re.compile(r'(%s)' % base_pattern)
+ comment_pattern = input_api.re.compile(r'//.*(%s)' % base_pattern)
+
+ problems = []
+ for f in input_api.AffectedSourceFiles(None):
+ local_path = f.LocalPath()
+ if not local_path.endswith('.h'):
+ continue
+ for line_number, line in f.ChangedContents():
+ if inclusion_pattern.search(line) and not comment_pattern.search(line):
+ problems.append(
+ '%s:%d\n %s' % (local_path, line_number, line.strip()))
+
+ if problems:
+ return [output_api.PresubmitPromptWarning(
+ _IPC_ENUM_TRAITS_DEPRECATED, problems)]
+ else:
+ return []
+
+
+def CheckChangeOnUpload(input_api, output_api):
+ results = []
+ results.extend(_CommonChecks(input_api, output_api))
+ results.extend(_CheckValidHostsInDEPS(input_api, output_api))
+ results.extend(_CheckJavaStyle(input_api, output_api))
+ return results
+
+
+def GetTryServerMasterForBot(bot):
+ """Returns the Try Server master for the given bot.
+
+ It tries to guess the master from the bot name, but may still fail
+ and return None. There is no longer a default master.
+ """
+ # Potentially ambiguous bot names are listed explicitly.
+ master_map = {
+ 'linux_gpu': 'tryserver.chromium.gpu',
+ 'mac_gpu': 'tryserver.chromium.gpu',
+ 'win_gpu': 'tryserver.chromium.gpu',
+ 'chromium_presubmit': 'tryserver.chromium.linux',
+ 'blink_presubmit': 'tryserver.chromium.linux',
+ 'tools_build_presubmit': 'tryserver.chromium.linux',
+ }
+ master = master_map.get(bot)
+ if not master:
+ if 'gpu' in bot:
+ master = 'tryserver.chromium.gpu'
+ elif 'linux' in bot or 'android' in bot or 'presubmit' in bot:
+ master = 'tryserver.chromium.linux'
+ elif 'win' in bot:
+ master = 'tryserver.chromium.win'
+ elif 'mac' in bot or 'ios' in bot:
+ master = 'tryserver.chromium.mac'
+ return master
+
+
+def GetDefaultTryConfigs(bots=None):
+ """Returns a list of ('bot', set(['tests']), optionally filtered by [bots].
+
+ To add tests to this list, they MUST be in the the corresponding master's
+ gatekeeper config. For example, anything on master.chromium would be closed by
+ tools/build/masters/master.chromium/master_gatekeeper_cfg.py.
+
+ If 'bots' is specified, will only return configurations for bots in that list.
+ """
+
+ standard_tests = [
+ 'base_unittests',
+ 'browser_tests',
+ 'cacheinvalidation_unittests',
+ 'check_deps',
+ 'check_deps2git',
+ 'content_browsertests',
+ 'content_unittests',
+ 'crypto_unittests',
+ 'gpu_unittests',
+ 'interactive_ui_tests',
+ 'ipc_tests',
+ 'jingle_unittests',
+ 'media_unittests',
+ 'net_unittests',
+ 'ppapi_unittests',
+ 'printing_unittests',
+ 'sql_unittests',
+ 'sync_unit_tests',
+ 'unit_tests',
+ # Broken in release.
+ #'url_unittests',
+ #'webkit_unit_tests',
+ ]
+
+ builders_and_tests = {
+ # TODO(maruel): Figure out a way to run 'sizes' where people can
+ # effectively update the perf expectation correctly. This requires a
+ # clobber=True build running 'sizes'. 'sizes' is not accurate with
+ # incremental build. Reference:
+ # http://chromium.org/developers/tree-sheriffs/perf-sheriffs.
+ # TODO(maruel): An option would be to run 'sizes' but not count a failure
+ # of this step as a try job failure.
+ 'android_aosp': ['compile'],
+ 'android_arm64_dbg_recipe': ['slave_steps'],
+ 'android_chromium_gn_compile_dbg': ['compile'],
+ 'android_chromium_gn_compile_rel': ['compile'],
+ 'android_clang_dbg': ['slave_steps'],
+ 'android_clang_dbg_recipe': ['slave_steps'],
+ 'android_dbg_tests_recipe': ['slave_steps'],
+ 'cros_x86': ['defaulttests'],
+ 'ios_dbg_simulator': [
+ 'compile',
+ 'base_unittests',
+ 'content_unittests',
+ 'crypto_unittests',
+ 'url_unittests',
+ 'net_unittests',
+ 'sql_unittests',
+ 'ui_base_unittests',
+ 'ui_unittests',
+ ],
+ 'ios_rel_device': ['compile'],
+ 'ios_rel_device_ninja': ['compile'],
+ 'linux_asan': ['compile'],
+ 'mac_asan': ['compile'],
+ #TODO(stip): Change the name of this builder to reflect that it's release.
+ 'linux_gtk': standard_tests,
+ 'linux_chromeos_asan': ['compile'],
+ 'linux_chromium_chromeos_clang_dbg': ['defaulttests'],
+ 'linux_chromium_chromeos_rel_swarming': ['defaulttests'],
+ 'linux_chromium_compile_dbg': ['defaulttests'],
+ 'linux_chromium_gn_dbg': ['compile'],
+ 'linux_chromium_gn_rel': ['defaulttests'],
+ 'linux_chromium_rel_swarming': ['defaulttests'],
+ 'linux_chromium_clang_dbg': ['defaulttests'],
+ 'linux_gpu': ['defaulttests'],
+ 'linux_nacl_sdk_build': ['compile'],
+ 'mac_chromium_compile_dbg': ['defaulttests'],
+ 'mac_chromium_rel_swarming': ['defaulttests'],
+ 'mac_gpu': ['defaulttests'],
+ 'mac_nacl_sdk_build': ['compile'],
+ 'win_chromium_compile_dbg': ['defaulttests'],
+ 'win_chromium_dbg': ['defaulttests'],
+ 'win_chromium_rel_swarming': ['defaulttests'],
+ 'win_chromium_x64_rel_swarming': ['defaulttests'],
+ 'win_gpu': ['defaulttests'],
+ 'win_nacl_sdk_build': ['compile'],
+ 'win8_chromium_rel': ['defaulttests'],
+ }
+
+ if bots:
+ filtered_builders_and_tests = dict((bot, set(builders_and_tests[bot]))
+ for bot in bots)
+ else:
+ filtered_builders_and_tests = dict(
+ (bot, set(tests))
+ for bot, tests in builders_and_tests.iteritems())
+
+ # Build up the mapping from tryserver master to bot/test.
+ out = dict()
+ for bot, tests in filtered_builders_and_tests.iteritems():
+ out.setdefault(GetTryServerMasterForBot(bot), {})[bot] = tests
+ return out
+
+
+def CheckChangeOnCommit(input_api, output_api):
+ results = []
+ results.extend(_CommonChecks(input_api, output_api))
+ # TODO(thestig) temporarily disabled, doesn't work in third_party/
+ #results.extend(input_api.canned_checks.CheckSvnModifiedDirectories(
+ # input_api, output_api, sources))
+ # Make sure the tree is 'open'.
+ results.extend(input_api.canned_checks.CheckTreeIsOpen(
+ input_api,
+ output_api,
+ json_url='http://chromium-status.appspot.com/current?format=json'))
+
+ results.extend(input_api.canned_checks.CheckChangeHasBugField(
+ input_api, output_api))
+ results.extend(input_api.canned_checks.CheckChangeHasDescription(
+ input_api, output_api))
+ return results
+
+
+def GetPreferredTryMasters(project, change):
+ files = change.LocalPaths()
+
+ if not files or all(re.search(r'[\\\/]OWNERS$', f) for f in files):
+ return {}
+
+ if all(re.search(r'\.(m|mm)$|(^|[\\\/_])mac[\\\/_.]', f) for f in files):
+ return GetDefaultTryConfigs([
+ 'mac_chromium_compile_dbg',
+ 'mac_chromium_rel_swarming',
+ ])
+ if all(re.search('(^|[/_])win[/_.]', f) for f in files):
+ return GetDefaultTryConfigs([
+ 'win_chromium_dbg',
+ 'win_chromium_rel_swarming',
+ 'win8_chromium_rel',
+ ])
+ if all(re.search(r'(^|[\\\/_])android[\\\/_.]', f) for f in files):
+ return GetDefaultTryConfigs([
+ 'android_aosp',
+ 'android_clang_dbg',
+ 'android_dbg_tests_recipe',
+ ])
+ if all(re.search(r'[\\\/_]ios[\\\/_.]', f) for f in files):
+ return GetDefaultTryConfigs(['ios_rel_device', 'ios_dbg_simulator'])
+
+ builders = [
+ 'android_arm64_dbg_recipe',
+ 'android_chromium_gn_compile_rel',
+ 'android_chromium_gn_compile_dbg',
+ 'android_clang_dbg',
+ 'android_clang_dbg_recipe',
+ 'android_dbg_tests_recipe',
+ 'ios_dbg_simulator',
+ 'ios_rel_device',
+ 'ios_rel_device_ninja',
+ 'linux_chromium_chromeos_rel_swarming',
+ 'linux_chromium_clang_dbg',
+ 'linux_chromium_gn_dbg',
+ 'linux_chromium_gn_rel',
+ 'linux_chromium_rel_swarming',
+ 'linux_gpu',
+ 'mac_chromium_compile_dbg',
+ 'mac_chromium_rel_swarming',
+ 'mac_gpu',
+ 'win_chromium_compile_dbg',
+ 'win_chromium_rel_swarming',
+ 'win_chromium_x64_rel_swarming',
+ 'win_gpu',
+ 'win8_chromium_rel',
+ ]
+
+ # Match things like path/aura/file.cc and path/file_aura.cc.
+ # Same for chromeos.
+ if any(re.search(r'[\\\/_](aura|chromeos)', f) for f in files):
+ builders.extend([
+ 'linux_chromeos_asan',
+ 'linux_chromium_chromeos_clang_dbg'
+ ])
+
+ # If there are gyp changes to base, build, or chromeos, run a full cros build
+ # in addition to the shorter linux_chromeos build. Changes to high level gyp
+ # files have a much higher chance of breaking the cros build, which is
+ # differnt from the linux_chromeos build that most chrome developers test
+ # with.
+ if any(re.search('^(base|build|chromeos).*\.gypi?$', f) for f in files):
+ builders.extend(['cros_x86'])
+
+ # The AOSP bot doesn't build the chrome/ layer, so ignore any changes to it
+ # unless they're .gyp(i) files as changes to those files can break the gyp
+ # step on that bot.
+ if (not all(re.search('^chrome', f) for f in files) or
+ any(re.search('\.gypi?$', f) for f in files)):
+ builders.extend(['android_aosp'])
+
+ return GetDefaultTryConfigs(builders)
