PRESUBMIT.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """Top-level presubmit script for Chromium.
   6
   7 See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
   8 for more details about the presubmit API built into gcl.
   9 """
  10
  11
  12 import re
  13 import subprocess
  14 import sys
  15
  16
  17 _EXCLUDED_PATHS = (
  18     r"^breakpad[\\\/].*",
  19     r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_rules.py",
  20     r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_simple.py",
  21     r"^net[\\\/]tools[\\\/]spdyshark[\\\/].*",
  22     r"^skia[\\\/].*",
  23     r"^v8[\\\/].*",
  24     r".*MakeFile$",
  25     r".+_autogen\.h$",
  26     r"^cc[\\\/].*",
  27     r"^webkit[\\\/]compositor_bindings[\\\/].*",
  28     r".+[\\\/]pnacl_shim\.c$",
  29 )
  30
  31 # Fragment of a regular expression that matches file name suffixes
  32 # used to indicate different platforms.
  33 _PLATFORM_SPECIFIERS = r'(_(android|chromeos|gtk|mac|posix|win))?'
  34
  35 # Fragment of a regular expression that matches C++ and Objective-C++
  36 # implementation files.
  37 _IMPLEMENTATION_EXTENSIONS = r'\.(cc|cpp|cxx|mm)$'
  38
  39 # Regular expression that matches code only used for test binaries
  40 # (best effort).
  41 _TEST_CODE_EXCLUDED_PATHS = (
  42     r'.*[/\\](fake_|test_|mock_).+%s' % _IMPLEMENTATION_EXTENSIONS,
  43     r'.+_test_(base|support|util)%s' % _IMPLEMENTATION_EXTENSIONS,
  44     r'.+_(api|browser|perf|unit|ui)?test%s%s' % (_PLATFORM_SPECIFIERS,
  45                                                  _IMPLEMENTATION_EXTENSIONS),
  46     r'.+profile_sync_service_harness%s' % _IMPLEMENTATION_EXTENSIONS,
  47     r'.*[/\\](test|tool(s)?)[/\\].*',
  48     # At request of folks maintaining this folder.
  49     r'chrome[/\\]browser[/\\]automation[/\\].*',
  50 )
  51
  52 _TEST_ONLY_WARNING = (
  53     'You might be calling functions intended only for testing from\n'
  54     'production code.  It is OK to ignore this warning if you know what\n'
  55     'you are doing, as the heuristics used to detect the situation are\n'
  56     'not perfect.  The commit queue will not block on this warning.\n'
  57     'Email joi@chromium.org if you have questions.')
  58
  59
  60 _INCLUDE_ORDER_WARNING = (
  61     'Your #include order seems to be broken. Send mail to\n'
  62     'marja@chromium.org if this is not the case.')
  63
  64
  65 _BANNED_OBJC_FUNCTIONS = (
  66     (
  67       'addTrackingRect:',
  68       (
  69        'The use of -[NSView addTrackingRect:owner:userData:assumeInside:] is'
  70        'prohibited. Please use CrTrackingArea instead.',
  71        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  72       ),
  73       False,
  74     ),
  75     (
  76       'NSTrackingArea',
  77       (
  78        'The use of NSTrackingAreas is prohibited. Please use CrTrackingArea',
  79        'instead.',
  80        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  81       ),
  82       False,
  83     ),
  84     (
  85       'convertPointFromBase:',
  86       (
  87        'The use of -[NSView convertPointFromBase:] is almost certainly wrong.',
  88        'Please use |convertPoint:(point) fromView:nil| instead.',
  89        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  90       ),
  91       True,
  92     ),
  93     (
  94       'convertPointToBase:',
  95       (
  96        'The use of -[NSView convertPointToBase:] is almost certainly wrong.',
  97        'Please use |convertPoint:(point) toView:nil| instead.',
  98        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  99       ),
 100       True,
 101     ),
 102     (
 103       'convertRectFromBase:',
 104       (
 105        'The use of -[NSView convertRectFromBase:] is almost certainly wrong.',
 106        'Please use |convertRect:(point) fromView:nil| instead.',
 107        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 108       ),
 109       True,
 110     ),
 111     (
 112       'convertRectToBase:',
 113       (
 114        'The use of -[NSView convertRectToBase:] is almost certainly wrong.',
 115        'Please use |convertRect:(point) toView:nil| instead.',
 116        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 117       ),
 118       True,
 119     ),
 120     (
 121       'convertSizeFromBase:',
 122       (
 123        'The use of -[NSView convertSizeFromBase:] is almost certainly wrong.',
 124        'Please use |convertSize:(point) fromView:nil| instead.',
 125        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 126       ),
 127       True,
 128     ),
 129     (
 130       'convertSizeToBase:',
 131       (
 132        'The use of -[NSView convertSizeToBase:] is almost certainly wrong.',
 133        'Please use |convertSize:(point) toView:nil| instead.',
 134        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 135       ),
 136       True,
 137     ),
 138 )
 139
 140
 141 _BANNED_CPP_FUNCTIONS = (
 142     # Make sure that gtest's FRIEND_TEST() macro is not used; the
 143     # FRIEND_TEST_ALL_PREFIXES() macro from base/gtest_prod_util.h should be
 144     # used instead since that allows for FLAKY_ and DISABLED_ prefixes.
 145     (
 146       'FRIEND_TEST(',
 147       (
 148        'Chromium code should not use gtest\'s FRIEND_TEST() macro. Include',
 149        'base/gtest_prod_util.h and use FRIEND_TEST_ALL_PREFIXES() instead.',
 150       ),
 151       False,
 152       (),
 153     ),
 154     (
 155       'ScopedAllowIO',
 156       (
 157        'New code should not use ScopedAllowIO. Post a task to the blocking',
 158        'pool or the FILE thread instead.',
 159       ),
 160       True,
 161       (
 162         r"^content[\\\/]shell[\\\/]shell_browser_main\.cc$",
 163       ),
 164     ),
 165     (
 166       'FilePathWatcher::Delegate',
 167       (
 168        'New code should not use FilePathWatcher::Delegate. Use the callback',
 169        'interface instead.',
 170       ),
 171       False,
 172       (),
 173     ),
 174     (
 175       'browser::FindOrCreateTabbedBrowserDeprecated',
 176       (
 177        'This function is deprecated and we\'re working on removing it. Pass',
 178        'more context to get a Browser*, like a WebContents, window, or session',
 179        'id. Talk to robertshield@ for more information.',
 180       ),
 181       True,
 182       (),
 183     ),
 184     (
 185       'RunAllPending()',
 186       (
 187        'This function is deprecated and we\'re working on removing it. Rename',
 188        'to RunUntilIdle',
 189       ),
 190       True,
 191       (),
 192     ),
 193 )
 194
 195
 196
 197 def _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api):
 198   """Attempts to prevent use of functions intended only for testing in
 199   non-testing code. For now this is just a best-effort implementation
 200   that ignores header files and may have some false positives. A
 201   better implementation would probably need a proper C++ parser.
 202   """
 203   # We only scan .cc files and the like, as the declaration of
 204   # for-testing functions in header files are hard to distinguish from
 205   # calls to such functions without a proper C++ parser.
 206   file_inclusion_pattern = r'.+%s' % _IMPLEMENTATION_EXTENSIONS
 207
 208   base_function_pattern = r'ForTest(ing)?|for_test(ing)?'
 209   inclusion_pattern = input_api.re.compile(r'(%s)\s*\(' % base_function_pattern)
 210   exclusion_pattern = input_api.re.compile(
 211     r'::[A-Za-z0-9_]+(%s)|(%s)[^;]+\{' % (
 212       base_function_pattern, base_function_pattern))
 213
 214   def FilterFile(affected_file):
 215     black_list = (_EXCLUDED_PATHS +
 216                   _TEST_CODE_EXCLUDED_PATHS +
 217                   input_api.DEFAULT_BLACK_LIST)
 218     return input_api.FilterSourceFile(
 219       affected_file,
 220       white_list=(file_inclusion_pattern, ),
 221       black_list=black_list)
 222
 223   problems = []
 224   for f in input_api.AffectedSourceFiles(FilterFile):
 225     local_path = f.LocalPath()
 226     lines = input_api.ReadFile(f).splitlines()
 227     line_number = 0
 228     for line in lines:
 229       if (inclusion_pattern.search(line) and
 230           not exclusion_pattern.search(line)):
 231         problems.append(
 232           '%s:%d\n    %s' % (local_path, line_number, line.strip()))
 233       line_number += 1
 234
 235   if problems:
 236     if not input_api.is_committing:
 237       return [output_api.PresubmitPromptWarning(_TEST_ONLY_WARNING, problems)]
 238     else:
 239       # We don't warn on commit, to avoid stopping commits going through CQ.
 240       return [output_api.PresubmitNotifyResult(_TEST_ONLY_WARNING, problems)]
 241   else:
 242     return []
 243
 244
 245 def _CheckNoIOStreamInHeaders(input_api, output_api):
 246   """Checks to make sure no .h files include <iostream>."""
 247   files = []
 248   pattern = input_api.re.compile(r'^#include\s*<iostream>',
 249                                  input_api.re.MULTILINE)
 250   for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
 251     if not f.LocalPath().endswith('.h'):
 252       continue
 253     contents = input_api.ReadFile(f)
 254     if pattern.search(contents):
 255       files.append(f)
 256
 257   if len(files):
 258     return [ output_api.PresubmitError(
 259         'Do not #include <iostream> in header files, since it inserts static '
 260         'initialization into every file including the header. Instead, '
 261         '#include <ostream>. See http://crbug.com/94794',
 262         files) ]
 263   return []
 264
 265
 266 def _CheckNoUNIT_TESTInSourceFiles(input_api, output_api):
 267   """Checks to make sure no source files use UNIT_TEST"""
 268   problems = []
 269   for f in input_api.AffectedFiles():
 270     if (not f.LocalPath().endswith(('.cc', '.mm'))):
 271       continue
 272
 273     for line_num, line in f.ChangedContents():
 274       if 'UNIT_TEST' in line:
 275         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 276
 277   if not problems:
 278     return []
 279   return [output_api.PresubmitPromptWarning('UNIT_TEST is only for headers.\n' +
 280       '\n'.join(problems))]
 281
 282
 283 def _CheckNoNewWStrings(input_api, output_api):
 284   """Checks to make sure we don't introduce use of wstrings."""
 285   problems = []
 286   for f in input_api.AffectedFiles():
 287     if (not f.LocalPath().endswith(('.cc', '.h')) or
 288         f.LocalPath().endswith('test.cc')):
 289       continue
 290
 291     allowWString = False
 292     for line_num, line in f.ChangedContents():
 293       if 'presubmit: allow wstring' in line:
 294         allowWString = True
 295       elif not allowWString and 'wstring' in line:
 296         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 297         allowWString = False
 298       else:
 299         allowWString = False
 300
 301   if not problems:
 302     return []
 303   return [output_api.PresubmitPromptWarning('New code should not use wstrings.'
 304       '  If you are calling a cross-platform API that accepts a wstring, '
 305       'fix the API.\n' +
 306       '\n'.join(problems))]
 307
 308
 309 def _CheckNoDEPSGIT(input_api, output_api):
 310   """Make sure .DEPS.git is never modified manually."""
 311   if any(f.LocalPath().endswith('.DEPS.git') for f in
 312       input_api.AffectedFiles()):
 313     return [output_api.PresubmitError(
 314       'Never commit changes to .DEPS.git. This file is maintained by an\n'
 315       'automated system based on what\'s in DEPS and your changes will be\n'
 316       'overwritten.\n'
 317       'See http://code.google.com/p/chromium/wiki/UsingNewGit#Rolling_DEPS\n'
 318       'for more information')]
 319   return []
 320
 321
 322 def _CheckNoBannedFunctions(input_api, output_api):
 323   """Make sure that banned functions are not used."""
 324   warnings = []
 325   errors = []
 326
 327   file_filter = lambda f: f.LocalPath().endswith(('.mm', '.m', '.h'))
 328   for f in input_api.AffectedFiles(file_filter=file_filter):
 329     for line_num, line in f.ChangedContents():
 330       for func_name, message, error in _BANNED_OBJC_FUNCTIONS:
 331         if func_name in line:
 332           problems = warnings;
 333           if error:
 334             problems = errors;
 335           problems.append('    %s:%d:' % (f.LocalPath(), line_num))
 336           for message_line in message:
 337             problems.append('      %s' % message_line)
 338
 339   file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))
 340   for f in input_api.AffectedFiles(file_filter=file_filter):
 341     for line_num, line in f.ChangedContents():
 342       for func_name, message, error, excluded_paths in _BANNED_CPP_FUNCTIONS:
 343         def IsBlacklisted(affected_file, blacklist):
 344           local_path = affected_file.LocalPath()
 345           for item in blacklist:
 346             if input_api.re.match(item, local_path):
 347               return True
 348           return False
 349         if IsBlacklisted(f, excluded_paths):
 350           continue
 351         if func_name in line:
 352           problems = warnings;
 353           if error:
 354             problems = errors;
 355           problems.append('    %s:%d:' % (f.LocalPath(), line_num))
 356           for message_line in message:
 357             problems.append('      %s' % message_line)
 358
 359   result = []
 360   if (warnings):
 361     result.append(output_api.PresubmitPromptWarning(
 362         'Banned functions were used.\n' + '\n'.join(warnings)))
 363   if (errors):
 364     result.append(output_api.PresubmitError(
 365         'Banned functions were used.\n' + '\n'.join(errors)))
 366   return result
 367
 368
 369 def _CheckNoPragmaOnce(input_api, output_api):
 370   """Make sure that banned functions are not used."""
 371   files = []
 372   pattern = input_api.re.compile(r'^#pragma\s+once',
 373                                  input_api.re.MULTILINE)
 374   for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
 375     if not f.LocalPath().endswith('.h'):
 376       continue
 377     contents = input_api.ReadFile(f)
 378     if pattern.search(contents):
 379       files.append(f)
 380
 381   if files:
 382     return [output_api.PresubmitError(
 383         'Do not use #pragma once in header files.\n'
 384         'See http://www.chromium.org/developers/coding-style#TOC-File-headers',
 385         files)]
 386   return []
 387
 388
 389 def _CheckNoTrinaryTrueFalse(input_api, output_api):
 390   """Checks to make sure we don't introduce use of foo ? true : false."""
 391   problems = []
 392   pattern = input_api.re.compile(r'\?\s*(true|false)\s*:\s*(true|false)')
 393   for f in input_api.AffectedFiles():
 394     if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')):
 395       continue
 396
 397     for line_num, line in f.ChangedContents():
 398       if pattern.match(line):
 399         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 400
 401   if not problems:
 402     return []
 403   return [output_api.PresubmitPromptWarning(
 404       'Please consider avoiding the "? true : false" pattern if possible.\n' +
 405       '\n'.join(problems))]
 406
 407
 408 def _CheckUnwantedDependencies(input_api, output_api):
 409   """Runs checkdeps on #include statements added in this
 410   change. Breaking - rules is an error, breaking ! rules is a
 411   warning.
 412   """
 413   # We need to wait until we have an input_api object and use this
 414   # roundabout construct to import checkdeps because this file is
 415   # eval-ed and thus doesn't have __file__.
 416   original_sys_path = sys.path
 417   try:
 418     sys.path = sys.path + [input_api.os_path.join(
 419         input_api.PresubmitLocalPath(), 'tools', 'checkdeps')]
 420     import checkdeps
 421     from cpp_checker import CppChecker
 422     from rules import Rule
 423   finally:
 424     # Restore sys.path to what it was before.
 425     sys.path = original_sys_path
 426
 427   added_includes = []
 428   for f in input_api.AffectedFiles():
 429     if not CppChecker.IsCppFile(f.LocalPath()):
 430       continue
 431
 432     changed_lines = [line for line_num, line in f.ChangedContents()]
 433     added_includes.append([f.LocalPath(), changed_lines])
 434
 435   deps_checker = checkdeps.DepsChecker()
 436
 437   error_descriptions = []
 438   warning_descriptions = []
 439   for path, rule_type, rule_description in deps_checker.CheckAddedCppIncludes(
 440       added_includes):
 441     description_with_path = '%s\n    %s' % (path, rule_description)
 442     if rule_type == Rule.DISALLOW:
 443       error_descriptions.append(description_with_path)
 444     else:
 445       warning_descriptions.append(description_with_path)
 446
 447   results = []
 448   if error_descriptions:
 449     results.append(output_api.PresubmitError(
 450         'You added one or more #includes that violate checkdeps rules.',
 451         error_descriptions))
 452   if warning_descriptions:
 453     if not input_api.is_committing:
 454       warning_factory = output_api.PresubmitPromptWarning
 455     else:
 456       # We don't want to block use of the CQ when there is a warning
 457       # of this kind, so we only show a message when committing.
 458       warning_factory = output_api.PresubmitNotifyResult
 459     results.append(warning_factory(
 460         'You added one or more #includes of files that are temporarily\n'
 461         'allowed but being removed. Can you avoid introducing the\n'
 462         '#include? See relevant DEPS file(s) for details and contacts.',
 463         warning_descriptions))
 464   return results
 465
 466
 467 def _CheckFilePermissions(input_api, output_api):
 468   """Check that all files have their permissions properly set."""
 469   args = [sys.executable, 'tools/checkperms/checkperms.py', '--root',
 470           input_api.change.RepositoryRoot()]
 471   for f in input_api.AffectedFiles():
 472     args += ['--file', f.LocalPath()]
 473   errors = []
 474   (errors, stderrdata) = subprocess.Popen(args).communicate()
 475
 476   results = []
 477   if errors:
 478     results.append(output_api.PresubmitError('checkperms.py failed.',
 479                                              errors))
 480   return results
 481
 482
 483 def _CheckNoAuraWindowPropertyHInHeaders(input_api, output_api):
 484   """Makes sure we don't include ui/aura/window_property.h
 485   in header files.
 486   """
 487   pattern = input_api.re.compile(r'^#include\s*"ui/aura/window_property.h"')
 488   errors = []
 489   for f in input_api.AffectedFiles():
 490     if not f.LocalPath().endswith('.h'):
 491       continue
 492     for line_num, line in f.ChangedContents():
 493       if pattern.match(line):
 494         errors.append('    %s:%d' % (f.LocalPath(), line_num))
 495
 496   results = []
 497   if errors:
 498     results.append(output_api.PresubmitError(
 499       'Header files should not include ui/aura/window_property.h', errors))
 500   return results
 501
 502
 503 def _CheckIncludeOrderForScope(scope, input_api, file_path, changed_linenums):
 504   """Checks that the lines in scope occur in the right order.
 505
 506   1. C system files in alphabetical order
 507   2. C++ system files in alphabetical order
 508   3. Project's .h files
 509   """
 510
 511   c_system_include_pattern = input_api.re.compile(r'\s*#include <.*\.h>')
 512   cpp_system_include_pattern = input_api.re.compile(r'\s*#include <.*>')
 513   custom_include_pattern = input_api.re.compile(r'\s*#include ".*')
 514
 515   C_SYSTEM_INCLUDES, CPP_SYSTEM_INCLUDES, CUSTOM_INCLUDES = range(3)
 516
 517   state = C_SYSTEM_INCLUDES
 518
 519   previous_line = ''
 520   previous_line_num = 0
 521   problem_linenums = []
 522   for line_num, line in scope:
 523     if c_system_include_pattern.match(line):
 524       if state != C_SYSTEM_INCLUDES:
 525         problem_linenums.append((line_num, previous_line_num))
 526       elif previous_line and previous_line > line:
 527         problem_linenums.append((line_num, previous_line_num))
 528     elif cpp_system_include_pattern.match(line):
 529       if state == C_SYSTEM_INCLUDES:
 530         state = CPP_SYSTEM_INCLUDES
 531       elif state == CUSTOM_INCLUDES:
 532         problem_linenums.append((line_num, previous_line_num))
 533       elif previous_line and previous_line > line:
 534         problem_linenums.append((line_num, previous_line_num))
 535     elif custom_include_pattern.match(line):
 536       if state != CUSTOM_INCLUDES:
 537         state = CUSTOM_INCLUDES
 538       elif previous_line and previous_line > line:
 539         problem_linenums.append((line_num, previous_line_num))
 540     else:
 541       problem_linenums.append(line_num)
 542     previous_line = line
 543     previous_line_num = line_num
 544
 545   warnings = []
 546   for (line_num, previous_line_num) in problem_linenums:
 547     if line_num in changed_linenums or previous_line_num in changed_linenums:
 548       warnings.append('    %s:%d' % (file_path, line_num))
 549   return warnings
 550
 551
 552 def _CheckIncludeOrderInFile(input_api, f, changed_linenums):
 553   """Checks the #include order for the given file f."""
 554
 555   system_include_pattern = input_api.re.compile(r'\s*#include \<.*')
 556   # Exclude #include <.../...> includes from the check; e.g., <sys/...> includes
 557   # often need to appear in a specific order.
 558   excluded_include_pattern = input_api.re.compile(r'\s*#include \<.*/.*')
 559   custom_include_pattern = input_api.re.compile(r'\s*#include "(?P<FILE>.*)"')
 560   if_pattern = input_api.re.compile(
 561       r'\s*#\s*(if|elif|else|endif|define|undef).*')
 562   # Some files need specialized order of includes; exclude such files from this
 563   # check.
 564   uncheckable_includes_pattern = input_api.re.compile(
 565       r'\s*#include '
 566       '("ipc/.*macros\.h"|<windows\.h>|".*gl.*autogen.h")\s*')
 567
 568   contents = f.NewContents()
 569   warnings = []
 570   line_num = 0
 571
 572   # Handle the special first include. If the first include file is
 573   # some/path/file.h, the corresponding including file can be some/path/file.cc,
 574   # some/other/path/file.cc, some/path/file_platform.cc, some/path/file-suffix.h
 575   # etc. It's also possible that no special first include exists.
 576   for line in contents:
 577     line_num += 1
 578     if system_include_pattern.match(line):
 579       # No special first include -> process the line again along with normal
 580       # includes.
 581       line_num -= 1
 582       break
 583     match = custom_include_pattern.match(line)
 584     if match:
 585       match_dict = match.groupdict()
 586       header_basename = input_api.os_path.basename(
 587           match_dict['FILE']).replace('.h', '')
 588       if header_basename not in input_api.os_path.basename(f.LocalPath()):
 589         # No special first include -> process the line again along with normal
 590         # includes.
 591         line_num -= 1
 592       break
 593
 594   # Split into scopes: Each region between #if and #endif is its own scope.
 595   scopes = []
 596   current_scope = []
 597   for line in contents[line_num:]:
 598     line_num += 1
 599     if uncheckable_includes_pattern.match(line):
 600       return []
 601     if if_pattern.match(line):
 602       scopes.append(current_scope)
 603       current_scope = []
 604     elif ((system_include_pattern.match(line) or
 605            custom_include_pattern.match(line)) and
 606           not excluded_include_pattern.match(line)):
 607       current_scope.append((line_num, line))
 608   scopes.append(current_scope)
 609
 610   for scope in scopes:
 611     warnings.extend(_CheckIncludeOrderForScope(scope, input_api, f.LocalPath(),
 612                                                changed_linenums))
 613   return warnings
 614
 615
 616 def _CheckIncludeOrder(input_api, output_api):
 617   """Checks that the #include order is correct.
 618
 619   1. The corresponding header for source files.
 620   2. C system files in alphabetical order
 621   3. C++ system files in alphabetical order
 622   4. Project's .h files in alphabetical order
 623
 624   Each region separated by #if, #elif, #else, #endif, #define and #undef follows
 625   these rules separately.
 626   """
 627
 628   warnings = []
 629   for f in input_api.AffectedFiles():
 630     if f.LocalPath().endswith(('.cc', '.h')):
 631       changed_linenums = set(line_num for line_num, _ in f.ChangedContents())
 632       warnings.extend(_CheckIncludeOrderInFile(input_api, f, changed_linenums))
 633
 634   results = []
 635   if warnings:
 636     if not input_api.is_committing:
 637       results.append(output_api.PresubmitPromptWarning(_INCLUDE_ORDER_WARNING,
 638                                                        warnings))
 639     else:
 640       # We don't warn on commit, to avoid stopping commits going through CQ.
 641       results.append(output_api.PresubmitNotifyResult(_INCLUDE_ORDER_WARNING,
 642                                                       warnings))
 643   return results
 644
 645
 646 def _CheckForVersionControlConflictsInFile(input_api, f):
 647   pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$')
 648   errors = []
 649   for line_num, line in f.ChangedContents():
 650     if pattern.match(line):
 651       errors.append('    %s:%d %s' % (f.LocalPath(), line_num, line))
 652   return errors
 653
 654
 655 def _CheckForVersionControlConflicts(input_api, output_api):
 656   """Usually this is not intentional and will cause a compile failure."""
 657   errors = []
 658   for f in input_api.AffectedFiles():
 659     errors.extend(_CheckForVersionControlConflictsInFile(input_api, f))
 660
 661   results = []
 662   if errors:
 663     results.append(output_api.PresubmitError(
 664       'Version control conflict markers found, please resolve.', errors))
 665   return results
 666
 667
 668 def _CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api):
 669   def FilterFile(affected_file):
 670     """Filter function for use with input_api.AffectedSourceFiles,
 671     below.  This filters out everything except non-test files from
 672     top-level directories that generally speaking should not hard-code
 673     service URLs (e.g. src/android_webview/, src/content/ and others).
 674     """
 675     return input_api.FilterSourceFile(
 676       affected_file,
 677       white_list=(r'^(android_webview|base|content|net)[\\\/].*', ),
 678       black_list=(_EXCLUDED_PATHS +
 679                   _TEST_CODE_EXCLUDED_PATHS +
 680                   input_api.DEFAULT_BLACK_LIST))
 681
 682   pattern = input_api.re.compile('"[^"]*google\.com[^"]*"')
 683   problems = []  # items are (filename, line_number, line)
 684   for f in input_api.AffectedSourceFiles(FilterFile):
 685     for line_num, line in f.ChangedContents():
 686       if pattern.search(line):
 687         problems.append((f.LocalPath(), line_num, line))
 688
 689   if problems:
 690     if not input_api.is_committing:
 691       warning_factory = output_api.PresubmitPromptWarning
 692     else:
 693       # We don't want to block use of the CQ when there is a warning
 694       # of this kind, so we only show a message when committing.
 695       warning_factory = output_api.PresubmitNotifyResult
 696     return [warning_factory(
 697         'Most layers below src/chrome/ should not hardcode service URLs.\n'
 698         'Are you sure this is correct? (Contact: joi@chromium.org)',
 699         ['  %s:%d:  %s' % (
 700             problem[0], problem[1], problem[2]) for problem in problems])]
 701   else:
 702     return []
 703
 704
 705 def _CommonChecks(input_api, output_api):
 706   """Checks common to both upload and commit."""
 707   results = []
 708   results.extend(input_api.canned_checks.PanProjectChecks(
 709       input_api, output_api, excluded_paths=_EXCLUDED_PATHS))
 710   results.extend(_CheckAuthorizedAuthor(input_api, output_api))
 711   results.extend(
 712     _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api))
 713   results.extend(_CheckNoIOStreamInHeaders(input_api, output_api))
 714   results.extend(_CheckNoUNIT_TESTInSourceFiles(input_api, output_api))
 715   results.extend(_CheckNoNewWStrings(input_api, output_api))
 716   results.extend(_CheckNoDEPSGIT(input_api, output_api))
 717   results.extend(_CheckNoBannedFunctions(input_api, output_api))
 718   results.extend(_CheckNoPragmaOnce(input_api, output_api))
 719   results.extend(_CheckNoTrinaryTrueFalse(input_api, output_api))
 720   results.extend(_CheckUnwantedDependencies(input_api, output_api))
 721   results.extend(_CheckFilePermissions(input_api, output_api))
 722   results.extend(_CheckNoAuraWindowPropertyHInHeaders(input_api, output_api))
 723   results.extend(_CheckIncludeOrder(input_api, output_api))
 724   results.extend(_CheckForVersionControlConflicts(input_api, output_api))
 725   results.extend(_CheckPatchFiles(input_api, output_api))
 726   results.extend(_CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api))
 727
 728   if any('PRESUBMIT.py' == f.LocalPath() for f in input_api.AffectedFiles()):
 729     results.extend(input_api.canned_checks.RunUnitTestsInDirectory(
 730         input_api, output_api,
 731         input_api.PresubmitLocalPath(),
 732         whitelist=[r'.+_test\.py$']))
 733   return results
 734
 735
 736 def _CheckSubversionConfig(input_api, output_api):
 737   """Verifies the subversion config file is correctly setup.
 738
 739   Checks that autoprops are enabled, returns an error otherwise.
 740   """
 741   join = input_api.os_path.join
 742   if input_api.platform == 'win32':
 743     appdata = input_api.environ.get('APPDATA', '')
 744     if not appdata:
 745       return [output_api.PresubmitError('%APPDATA% is not configured.')]
 746     path = join(appdata, 'Subversion', 'config')
 747   else:
 748     home = input_api.environ.get('HOME', '')
 749     if not home:
 750       return [output_api.PresubmitError('$HOME is not configured.')]
 751     path = join(home, '.subversion', 'config')
 752
 753   error_msg = (
 754       'Please look at http://dev.chromium.org/developers/coding-style to\n'
 755       'configure your subversion configuration file. This enables automatic\n'
 756       'properties to simplify the project maintenance.\n'
 757       'Pro-tip: just download and install\n'
 758       'http://src.chromium.org/viewvc/chrome/trunk/tools/build/slave/config\n')
 759
 760   try:
 761     lines = open(path, 'r').read().splitlines()
 762     # Make sure auto-props is enabled and check for 2 Chromium standard
 763     # auto-prop.
 764     if (not '*.cc = svn:eol-style=LF' in lines or
 765         not '*.pdf = svn:mime-type=application/pdf' in lines or
 766         not 'enable-auto-props = yes' in lines):
 767       return [
 768           output_api.PresubmitNotifyResult(
 769               'It looks like you have not configured your subversion config '
 770               'file or it is not up-to-date.\n' + error_msg)
 771       ]
 772   except (OSError, IOError):
 773     return [
 774         output_api.PresubmitNotifyResult(
 775             'Can\'t find your subversion config file.\n' + error_msg)
 776     ]
 777   return []
 778
 779
 780 def _CheckAuthorizedAuthor(input_api, output_api):
 781   """For non-googler/chromites committers, verify the author's email address is
 782   in AUTHORS.
 783   """
 784   # TODO(maruel): Add it to input_api?
 785   import fnmatch
 786
 787   author = input_api.change.author_email
 788   if not author:
 789     input_api.logging.info('No author, skipping AUTHOR check')
 790     return []
 791   authors_path = input_api.os_path.join(
 792       input_api.PresubmitLocalPath(), 'AUTHORS')
 793   valid_authors = (
 794       input_api.re.match(r'[^#]+\s+\<(.+?)\>\s*$', line)
 795       for line in open(authors_path))
 796   valid_authors = [item.group(1).lower() for item in valid_authors if item]
 797   if input_api.verbose:
 798     print 'Valid authors are %s' % ', '.join(valid_authors)
 799   if not any(fnmatch.fnmatch(author.lower(), valid) for valid in valid_authors):
 800     return [output_api.PresubmitPromptWarning(
 801         ('%s is not in AUTHORS file. If you are a new contributor, please visit'
 802         '\n'
 803         'http://www.chromium.org/developers/contributing-code and read the '
 804         '"Legal" section\n'
 805         'If you are a chromite, verify the contributor signed the CLA.') %
 806         author)]
 807   return []
 808
 809
 810 def _CheckPatchFiles(input_api, output_api):
 811   problems = [f.LocalPath() for f in input_api.AffectedFiles()
 812       if f.LocalPath().endswith(('.orig', '.rej'))]
 813   if problems:
 814     return [output_api.PresubmitError(
 815         "Don't commit .rej and .orig files.", problems)]
 816   else:
 817     return []
 818
 819
 820 def CheckChangeOnUpload(input_api, output_api):
 821   results = []
 822   results.extend(_CommonChecks(input_api, output_api))
 823   return results
 824
 825
 826 def CheckChangeOnCommit(input_api, output_api):
 827   results = []
 828   results.extend(_CommonChecks(input_api, output_api))
 829   # TODO(thestig) temporarily disabled, doesn't work in third_party/
 830   #results.extend(input_api.canned_checks.CheckSvnModifiedDirectories(
 831   #    input_api, output_api, sources))
 832   # Make sure the tree is 'open'.
 833   results.extend(input_api.canned_checks.CheckTreeIsOpen(
 834       input_api,
 835       output_api,
 836       json_url='http://chromium-status.appspot.com/current?format=json'))
 837   results.extend(input_api.canned_checks.CheckRietveldTryJobExecution(input_api,
 838       output_api, 'http://codereview.chromium.org',
 839       ('win_rel', 'linux_rel', 'mac_rel, win:compile'),
 840       'tryserver@chromium.org'))
 841
 842   results.extend(input_api.canned_checks.CheckChangeHasBugField(
 843       input_api, output_api))
 844   results.extend(input_api.canned_checks.CheckChangeHasDescription(
 845       input_api, output_api))
 846   results.extend(_CheckSubversionConfig(input_api, output_api))
 847   return results
 848
 849
 850 def GetPreferredTrySlaves(project, change):
 851   files = change.LocalPaths()
 852
 853   if not files:
 854     return []
 855
 856   if all(re.search('\.(m|mm)$|(^|[/_])mac[/_.]', f) for f in files):
 857     return ['mac_rel', 'mac_asan']
 858   if all(re.search('(^|[/_])win[/_.]', f) for f in files):
 859     return ['win_rel']
 860   if all(re.search('(^|[/_])android[/_.]', f) for f in files):
 861     return ['android_dbg', 'android_clang_dbg']
 862   if all(re.search('^native_client_sdk', f) for f in files):
 863     return ['linux_nacl_sdk', 'win_nacl_sdk', 'mac_nacl_sdk']
 864   if all(re.search('[/_]ios[/_.]', f) for f in files):
 865     return ['ios_rel_device', 'ios_dbg_simulator']
 866
 867   trybots = [
 868       'android_clang_dbg',
 869       'android_dbg',
 870       'ios_dbg_simulator',
 871       'ios_rel_device',
 872       'linux_asan',
 873       'linux_aura',
 874       'linux_chromeos',
 875       'linux_clang:compile',
 876       'linux_rel',
 877       'mac_asan',
 878       'mac_rel',
 879       'win_aura',
 880       'win_rel',
 881   ]
 882
 883   # Match things like path/aura/file.cc and path/file_aura.cc.
 884   # Same for chromeos.
 885   if any(re.search('[/_](aura|chromeos)', f) for f in files):
 886     trybots += ['linux_chromeos_clang:compile', 'linux_chromeos_asan']
 887
 888   return trybots