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 sys
  14
  15
  16 _EXCLUDED_PATHS = (
  17     r"^breakpad[\\\/].*",
  18     r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_rules.py",
  19     r"^native_client_sdk[\\\/]src[\\\/]build_tools[\\\/]make_simple.py",
  20     r"^native_client_sdk[\\\/]src[\\\/]tools[\\\/].*.mk",
  21     r"^net[\\\/]tools[\\\/]spdyshark[\\\/].*",
  22     r"^skia[\\\/].*",
  23     r"^v8[\\\/].*",
  24     r".*MakeFile$",
  25     r".+_autogen\.h$",
  26     r".+[\\\/]pnacl_shim\.c$",
  27     r"^gpu[\\\/]config[\\\/].*_list_json\.cc$",
  28     r"^chrome[\\\/]browser[\\\/]resources[\\\/]pdf[\\\/]index.js"
  29 )
  30
  31 # TestRunner and NetscapePlugIn library is temporarily excluded from pan-project
  32 # checks until it's transitioned to chromium coding style.
  33 _TESTRUNNER_PATHS = (
  34     r"^content[\\\/]shell[\\\/]renderer[\\\/]test_runner[\\\/].*",
  35     r"^content[\\\/]shell[\\\/]tools[\\\/]plugin[\\\/].*",
  36 )
  37
  38 # Fragment of a regular expression that matches C++ and Objective-C++
  39 # implementation files.
  40 _IMPLEMENTATION_EXTENSIONS = r'\.(cc|cpp|cxx|mm)$'
  41
  42 # Regular expression that matches code only used for test binaries
  43 # (best effort).
  44 _TEST_CODE_EXCLUDED_PATHS = (
  45     r'.*[/\\](fake_|test_|mock_).+%s' % _IMPLEMENTATION_EXTENSIONS,
  46     r'.+_test_(base|support|util)%s' % _IMPLEMENTATION_EXTENSIONS,
  47     r'.+_(api|browser|kif|perf|pixel|unit|ui)?test(_[a-z]+)?%s' %
  48         _IMPLEMENTATION_EXTENSIONS,
  49     r'.+profile_sync_service_harness%s' % _IMPLEMENTATION_EXTENSIONS,
  50     r'.*[/\\](test|tool(s)?)[/\\].*',
  51     # content_shell is used for running layout tests.
  52     r'content[/\\]shell[/\\].*',
  53     # At request of folks maintaining this folder.
  54     r'chrome[/\\]browser[/\\]automation[/\\].*',
  55     # Non-production example code.
  56     r'mojo[/\\]examples[/\\].*',
  57 )
  58
  59 _TEST_ONLY_WARNING = (
  60     'You might be calling functions intended only for testing from\n'
  61     'production code.  It is OK to ignore this warning if you know what\n'
  62     'you are doing, as the heuristics used to detect the situation are\n'
  63     'not perfect.  The commit queue will not block on this warning.')
  64
  65
  66 _INCLUDE_ORDER_WARNING = (
  67     'Your #include order seems to be broken. Send mail to\n'
  68     'marja@chromium.org if this is not the case.')
  69
  70
  71 _BANNED_OBJC_FUNCTIONS = (
  72     (
  73       'addTrackingRect:',
  74       (
  75        'The use of -[NSView addTrackingRect:owner:userData:assumeInside:] is'
  76        'prohibited. Please use CrTrackingArea instead.',
  77        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  78       ),
  79       False,
  80     ),
  81     (
  82       r'/NSTrackingArea\W',
  83       (
  84        'The use of NSTrackingAreas is prohibited. Please use CrTrackingArea',
  85        'instead.',
  86        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  87       ),
  88       False,
  89     ),
  90     (
  91       'convertPointFromBase:',
  92       (
  93        'The use of -[NSView convertPointFromBase:] is almost certainly wrong.',
  94        'Please use |convertPoint:(point) fromView:nil| instead.',
  95        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
  96       ),
  97       True,
  98     ),
  99     (
 100       'convertPointToBase:',
 101       (
 102        'The use of -[NSView convertPointToBase:] is almost certainly wrong.',
 103        'Please use |convertPoint:(point) toView:nil| instead.',
 104        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 105       ),
 106       True,
 107     ),
 108     (
 109       'convertRectFromBase:',
 110       (
 111        'The use of -[NSView convertRectFromBase:] is almost certainly wrong.',
 112        'Please use |convertRect:(point) fromView:nil| instead.',
 113        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 114       ),
 115       True,
 116     ),
 117     (
 118       'convertRectToBase:',
 119       (
 120        'The use of -[NSView convertRectToBase:] is almost certainly wrong.',
 121        'Please use |convertRect:(point) toView:nil| instead.',
 122        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 123       ),
 124       True,
 125     ),
 126     (
 127       'convertSizeFromBase:',
 128       (
 129        'The use of -[NSView convertSizeFromBase:] is almost certainly wrong.',
 130        'Please use |convertSize:(point) fromView:nil| instead.',
 131        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 132       ),
 133       True,
 134     ),
 135     (
 136       'convertSizeToBase:',
 137       (
 138        'The use of -[NSView convertSizeToBase:] is almost certainly wrong.',
 139        'Please use |convertSize:(point) toView:nil| instead.',
 140        'http://dev.chromium.org/developers/coding-style/cocoa-dos-and-donts',
 141       ),
 142       True,
 143     ),
 144 )
 145
 146
 147 _BANNED_CPP_FUNCTIONS = (
 148     # Make sure that gtest's FRIEND_TEST() macro is not used; the
 149     # FRIEND_TEST_ALL_PREFIXES() macro from base/gtest_prod_util.h should be
 150     # used instead since that allows for FLAKY_ and DISABLED_ prefixes.
 151     (
 152       'FRIEND_TEST(',
 153       (
 154        'Chromium code should not use gtest\'s FRIEND_TEST() macro. Include',
 155        'base/gtest_prod_util.h and use FRIEND_TEST_ALL_PREFIXES() instead.',
 156       ),
 157       False,
 158       (),
 159     ),
 160     (
 161       'ScopedAllowIO',
 162       (
 163        'New code should not use ScopedAllowIO. Post a task to the blocking',
 164        'pool or the FILE thread instead.',
 165       ),
 166       True,
 167       (
 168         r"^components[\\\/]breakpad[\\\/]app[\\\/]breakpad_mac\.mm$",
 169         r"^content[\\\/]shell[\\\/]browser[\\\/]shell_browser_main\.cc$",
 170         r"^content[\\\/]shell[\\\/]browser[\\\/]shell_message_filter\.cc$",
 171         r"^mojo[\\\/]system[\\\/]raw_shared_buffer_posix\.cc$",
 172         r"^net[\\\/]disk_cache[\\\/]cache_util\.cc$",
 173         r"^net[\\\/]url_request[\\\/]test_url_fetcher_factory\.cc$",
 174       ),
 175     ),
 176     (
 177       'SkRefPtr',
 178       (
 179         'The use of SkRefPtr is prohibited. ',
 180         'Please use skia::RefPtr instead.'
 181       ),
 182       True,
 183       (),
 184     ),
 185     (
 186       'SkAutoRef',
 187       (
 188         'The indirect use of SkRefPtr via SkAutoRef is prohibited. ',
 189         'Please use skia::RefPtr instead.'
 190       ),
 191       True,
 192       (),
 193     ),
 194     (
 195       'SkAutoTUnref',
 196       (
 197         'The use of SkAutoTUnref is dangerous because it implicitly ',
 198         'converts to a raw pointer. Please use skia::RefPtr instead.'
 199       ),
 200       True,
 201       (),
 202     ),
 203     (
 204       'SkAutoUnref',
 205       (
 206         'The indirect use of SkAutoTUnref through SkAutoUnref is dangerous ',
 207         'because it implicitly converts to a raw pointer. ',
 208         'Please use skia::RefPtr instead.'
 209       ),
 210       True,
 211       (),
 212     ),
 213     (
 214       r'/HANDLE_EINTR\(.*close',
 215       (
 216        'HANDLE_EINTR(close) is invalid. If close fails with EINTR, the file',
 217        'descriptor will be closed, and it is incorrect to retry the close.',
 218        'Either call close directly and ignore its return value, or wrap close',
 219        'in IGNORE_EINTR to use its return value. See http://crbug.com/269623'
 220       ),
 221       True,
 222       (),
 223     ),
 224     (
 225       r'/IGNORE_EINTR\((?!.*close)',
 226       (
 227        'IGNORE_EINTR is only valid when wrapping close. To wrap other system',
 228        'calls, use HANDLE_EINTR. See http://crbug.com/269623',
 229       ),
 230       True,
 231       (
 232         # Files that #define IGNORE_EINTR.
 233         r'^base[\\\/]posix[\\\/]eintr_wrapper\.h$',
 234         r'^ppapi[\\\/]tests[\\\/]test_broker\.cc$',
 235       ),
 236     ),
 237     (
 238       r'/v8::Extension\(',
 239       (
 240         'Do not introduce new v8::Extensions into the code base, use',
 241         'gin::Wrappable instead. See http://crbug.com/334679',
 242       ),
 243       True,
 244       (
 245         r'extensions[/\\]renderer[/\\]safe_builtins\.*',
 246       ),
 247     ),
 248 )
 249
 250
 251 _VALID_OS_MACROS = (
 252     # Please keep sorted.
 253     'OS_ANDROID',
 254     'OS_ANDROID_HOST',
 255     'OS_BSD',
 256     'OS_CAT',       # For testing.
 257     'OS_CHROMEOS',
 258     'OS_FREEBSD',
 259     'OS_IOS',
 260     'OS_LINUX',
 261     'OS_MACOSX',
 262     'OS_NACL',
 263     'OS_OPENBSD',
 264     'OS_POSIX',
 265     'OS_QNX',
 266     'OS_SOLARIS',
 267     'OS_WIN',
 268 )
 269
 270
 271 def _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api):
 272   """Attempts to prevent use of functions intended only for testing in
 273   non-testing code. For now this is just a best-effort implementation
 274   that ignores header files and may have some false positives. A
 275   better implementation would probably need a proper C++ parser.
 276   """
 277   # We only scan .cc files and the like, as the declaration of
 278   # for-testing functions in header files are hard to distinguish from
 279   # calls to such functions without a proper C++ parser.
 280   file_inclusion_pattern = r'.+%s' % _IMPLEMENTATION_EXTENSIONS
 281
 282   base_function_pattern = r'[ :]test::[^\s]+|ForTest(ing)?|for_test(ing)?'
 283   inclusion_pattern = input_api.re.compile(r'(%s)\s*\(' % base_function_pattern)
 284   comment_pattern = input_api.re.compile(r'//.*(%s)' % base_function_pattern)
 285   exclusion_pattern = input_api.re.compile(
 286     r'::[A-Za-z0-9_]+(%s)|(%s)[^;]+\{' % (
 287       base_function_pattern, base_function_pattern))
 288
 289   def FilterFile(affected_file):
 290     black_list = (_EXCLUDED_PATHS +
 291                   _TEST_CODE_EXCLUDED_PATHS +
 292                   input_api.DEFAULT_BLACK_LIST)
 293     return input_api.FilterSourceFile(
 294       affected_file,
 295       white_list=(file_inclusion_pattern, ),
 296       black_list=black_list)
 297
 298   problems = []
 299   for f in input_api.AffectedSourceFiles(FilterFile):
 300     local_path = f.LocalPath()
 301     for line_number, line in f.ChangedContents():
 302       if (inclusion_pattern.search(line) and
 303           not comment_pattern.search(line) and
 304           not exclusion_pattern.search(line)):
 305         problems.append(
 306           '%s:%d\n    %s' % (local_path, line_number, line.strip()))
 307
 308   if problems:
 309     return [output_api.PresubmitPromptOrNotify(_TEST_ONLY_WARNING, problems)]
 310   else:
 311     return []
 312
 313
 314 def _CheckNoIOStreamInHeaders(input_api, output_api):
 315   """Checks to make sure no .h files include <iostream>."""
 316   files = []
 317   pattern = input_api.re.compile(r'^#include\s*<iostream>',
 318                                  input_api.re.MULTILINE)
 319   for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
 320     if not f.LocalPath().endswith('.h'):
 321       continue
 322     contents = input_api.ReadFile(f)
 323     if pattern.search(contents):
 324       files.append(f)
 325
 326   if len(files):
 327     return [ output_api.PresubmitError(
 328         'Do not #include <iostream> in header files, since it inserts static '
 329         'initialization into every file including the header. Instead, '
 330         '#include <ostream>. See http://crbug.com/94794',
 331         files) ]
 332   return []
 333
 334
 335 def _CheckNoUNIT_TESTInSourceFiles(input_api, output_api):
 336   """Checks to make sure no source files use UNIT_TEST"""
 337   problems = []
 338   for f in input_api.AffectedFiles():
 339     if (not f.LocalPath().endswith(('.cc', '.mm'))):
 340       continue
 341
 342     for line_num, line in f.ChangedContents():
 343       if 'UNIT_TEST ' in line or line.endswith('UNIT_TEST'):
 344         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 345
 346   if not problems:
 347     return []
 348   return [output_api.PresubmitPromptWarning('UNIT_TEST is only for headers.\n' +
 349       '\n'.join(problems))]
 350
 351
 352 def _CheckNoNewWStrings(input_api, output_api):
 353   """Checks to make sure we don't introduce use of wstrings."""
 354   problems = []
 355   for f in input_api.AffectedFiles():
 356     if (not f.LocalPath().endswith(('.cc', '.h')) or
 357         f.LocalPath().endswith(('test.cc', '_win.cc', '_win.h'))):
 358       continue
 359
 360     allowWString = False
 361     for line_num, line in f.ChangedContents():
 362       if 'presubmit: allow wstring' in line:
 363         allowWString = True
 364       elif not allowWString and 'wstring' in line:
 365         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 366         allowWString = False
 367       else:
 368         allowWString = False
 369
 370   if not problems:
 371     return []
 372   return [output_api.PresubmitPromptWarning('New code should not use wstrings.'
 373       '  If you are calling a cross-platform API that accepts a wstring, '
 374       'fix the API.\n' +
 375       '\n'.join(problems))]
 376
 377
 378 def _CheckNoDEPSGIT(input_api, output_api):
 379   """Make sure .DEPS.git is never modified manually."""
 380   if any(f.LocalPath().endswith('.DEPS.git') for f in
 381       input_api.AffectedFiles()):
 382     return [output_api.PresubmitError(
 383       'Never commit changes to .DEPS.git. This file is maintained by an\n'
 384       'automated system based on what\'s in DEPS and your changes will be\n'
 385       'overwritten.\n'
 386       'See http://code.google.com/p/chromium/wiki/UsingNewGit#Rolling_DEPS\n'
 387       'for more information')]
 388   return []
 389
 390
 391 def _CheckNoBannedFunctions(input_api, output_api):
 392   """Make sure that banned functions are not used."""
 393   warnings = []
 394   errors = []
 395
 396   file_filter = lambda f: f.LocalPath().endswith(('.mm', '.m', '.h'))
 397   for f in input_api.AffectedFiles(file_filter=file_filter):
 398     for line_num, line in f.ChangedContents():
 399       for func_name, message, error in _BANNED_OBJC_FUNCTIONS:
 400         matched = False
 401         if func_name[0:1] == '/':
 402           regex = func_name[1:]
 403           if input_api.re.search(regex, line):
 404             matched = True
 405         elif func_name in line:
 406             matched = True
 407         if matched:
 408           problems = warnings;
 409           if error:
 410             problems = errors;
 411           problems.append('    %s:%d:' % (f.LocalPath(), line_num))
 412           for message_line in message:
 413             problems.append('      %s' % message_line)
 414
 415   file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm', '.h'))
 416   for f in input_api.AffectedFiles(file_filter=file_filter):
 417     for line_num, line in f.ChangedContents():
 418       for func_name, message, error, excluded_paths in _BANNED_CPP_FUNCTIONS:
 419         def IsBlacklisted(affected_file, blacklist):
 420           local_path = affected_file.LocalPath()
 421           for item in blacklist:
 422             if input_api.re.match(item, local_path):
 423               return True
 424           return False
 425         if IsBlacklisted(f, excluded_paths):
 426           continue
 427         matched = False
 428         if func_name[0:1] == '/':
 429           regex = func_name[1:]
 430           if input_api.re.search(regex, line):
 431             matched = True
 432         elif func_name in line:
 433             matched = True
 434         if matched:
 435           problems = warnings;
 436           if error:
 437             problems = errors;
 438           problems.append('    %s:%d:' % (f.LocalPath(), line_num))
 439           for message_line in message:
 440             problems.append('      %s' % message_line)
 441
 442   result = []
 443   if (warnings):
 444     result.append(output_api.PresubmitPromptWarning(
 445         'Banned functions were used.\n' + '\n'.join(warnings)))
 446   if (errors):
 447     result.append(output_api.PresubmitError(
 448         'Banned functions were used.\n' + '\n'.join(errors)))
 449   return result
 450
 451
 452 def _CheckNoPragmaOnce(input_api, output_api):
 453   """Make sure that banned functions are not used."""
 454   files = []
 455   pattern = input_api.re.compile(r'^#pragma\s+once',
 456                                  input_api.re.MULTILINE)
 457   for f in input_api.AffectedSourceFiles(input_api.FilterSourceFile):
 458     if not f.LocalPath().endswith('.h'):
 459       continue
 460     contents = input_api.ReadFile(f)
 461     if pattern.search(contents):
 462       files.append(f)
 463
 464   if files:
 465     return [output_api.PresubmitError(
 466         'Do not use #pragma once in header files.\n'
 467         'See http://www.chromium.org/developers/coding-style#TOC-File-headers',
 468         files)]
 469   return []
 470
 471
 472 def _CheckNoTrinaryTrueFalse(input_api, output_api):
 473   """Checks to make sure we don't introduce use of foo ? true : false."""
 474   problems = []
 475   pattern = input_api.re.compile(r'\?\s*(true|false)\s*:\s*(true|false)')
 476   for f in input_api.AffectedFiles():
 477     if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')):
 478       continue
 479
 480     for line_num, line in f.ChangedContents():
 481       if pattern.match(line):
 482         problems.append('    %s:%d' % (f.LocalPath(), line_num))
 483
 484   if not problems:
 485     return []
 486   return [output_api.PresubmitPromptWarning(
 487       'Please consider avoiding the "? true : false" pattern if possible.\n' +
 488       '\n'.join(problems))]
 489
 490
 491 def _CheckUnwantedDependencies(input_api, output_api):
 492   """Runs checkdeps on #include statements added in this
 493   change. Breaking - rules is an error, breaking ! rules is a
 494   warning.
 495   """
 496   # We need to wait until we have an input_api object and use this
 497   # roundabout construct to import checkdeps because this file is
 498   # eval-ed and thus doesn't have __file__.
 499   original_sys_path = sys.path
 500   try:
 501     sys.path = sys.path + [input_api.os_path.join(
 502         input_api.PresubmitLocalPath(), 'tools', 'checkdeps')]
 503     import checkdeps
 504     from cpp_checker import CppChecker
 505     from rules import Rule
 506   finally:
 507     # Restore sys.path to what it was before.
 508     sys.path = original_sys_path
 509
 510   added_includes = []
 511   for f in input_api.AffectedFiles():
 512     if not CppChecker.IsCppFile(f.LocalPath()):
 513       continue
 514
 515     changed_lines = [line for line_num, line in f.ChangedContents()]
 516     added_includes.append([f.LocalPath(), changed_lines])
 517
 518   deps_checker = checkdeps.DepsChecker(input_api.PresubmitLocalPath())
 519
 520   error_descriptions = []
 521   warning_descriptions = []
 522   for path, rule_type, rule_description in deps_checker.CheckAddedCppIncludes(
 523       added_includes):
 524     description_with_path = '%s\n    %s' % (path, rule_description)
 525     if rule_type == Rule.DISALLOW:
 526       error_descriptions.append(description_with_path)
 527     else:
 528       warning_descriptions.append(description_with_path)
 529
 530   results = []
 531   if error_descriptions:
 532     results.append(output_api.PresubmitError(
 533         'You added one or more #includes that violate checkdeps rules.',
 534         error_descriptions))
 535   if warning_descriptions:
 536     results.append(output_api.PresubmitPromptOrNotify(
 537         'You added one or more #includes of files that are temporarily\n'
 538         'allowed but being removed. Can you avoid introducing the\n'
 539         '#include? See relevant DEPS file(s) for details and contacts.',
 540         warning_descriptions))
 541   return results
 542
 543
 544 def _CheckFilePermissions(input_api, output_api):
 545   """Check that all files have their permissions properly set."""
 546   if input_api.platform == 'win32':
 547     return []
 548   args = [sys.executable, 'tools/checkperms/checkperms.py', '--root',
 549           input_api.change.RepositoryRoot()]
 550   for f in input_api.AffectedFiles():
 551     args += ['--file', f.LocalPath()]
 552   checkperms = input_api.subprocess.Popen(args,
 553                                           stdout=input_api.subprocess.PIPE)
 554   errors = checkperms.communicate()[0].strip()
 555   if errors:
 556     return [output_api.PresubmitError('checkperms.py failed.',
 557                                       errors.splitlines())]
 558   return []
 559
 560
 561 def _CheckNoAuraWindowPropertyHInHeaders(input_api, output_api):
 562   """Makes sure we don't include ui/aura/window_property.h
 563   in header files.
 564   """
 565   pattern = input_api.re.compile(r'^#include\s*"ui/aura/window_property.h"')
 566   errors = []
 567   for f in input_api.AffectedFiles():
 568     if not f.LocalPath().endswith('.h'):
 569       continue
 570     for line_num, line in f.ChangedContents():
 571       if pattern.match(line):
 572         errors.append('    %s:%d' % (f.LocalPath(), line_num))
 573
 574   results = []
 575   if errors:
 576     results.append(output_api.PresubmitError(
 577       'Header files should not include ui/aura/window_property.h', errors))
 578   return results
 579
 580
 581 def _CheckIncludeOrderForScope(scope, input_api, file_path, changed_linenums):
 582   """Checks that the lines in scope occur in the right order.
 583
 584   1. C system files in alphabetical order
 585   2. C++ system files in alphabetical order
 586   3. Project's .h files
 587   """
 588
 589   c_system_include_pattern = input_api.re.compile(r'\s*#include <.*\.h>')
 590   cpp_system_include_pattern = input_api.re.compile(r'\s*#include <.*>')
 591   custom_include_pattern = input_api.re.compile(r'\s*#include ".*')
 592
 593   C_SYSTEM_INCLUDES, CPP_SYSTEM_INCLUDES, CUSTOM_INCLUDES = range(3)
 594
 595   state = C_SYSTEM_INCLUDES
 596
 597   previous_line = ''
 598   previous_line_num = 0
 599   problem_linenums = []
 600   for line_num, line in scope:
 601     if c_system_include_pattern.match(line):
 602       if state != C_SYSTEM_INCLUDES:
 603         problem_linenums.append((line_num, previous_line_num))
 604       elif previous_line and previous_line > line:
 605         problem_linenums.append((line_num, previous_line_num))
 606     elif cpp_system_include_pattern.match(line):
 607       if state == C_SYSTEM_INCLUDES:
 608         state = CPP_SYSTEM_INCLUDES
 609       elif state == CUSTOM_INCLUDES:
 610         problem_linenums.append((line_num, previous_line_num))
 611       elif previous_line and previous_line > line:
 612         problem_linenums.append((line_num, previous_line_num))
 613     elif custom_include_pattern.match(line):
 614       if state != CUSTOM_INCLUDES:
 615         state = CUSTOM_INCLUDES
 616       elif previous_line and previous_line > line:
 617         problem_linenums.append((line_num, previous_line_num))
 618     else:
 619       problem_linenums.append(line_num)
 620     previous_line = line
 621     previous_line_num = line_num
 622
 623   warnings = []
 624   for (line_num, previous_line_num) in problem_linenums:
 625     if line_num in changed_linenums or previous_line_num in changed_linenums:
 626       warnings.append('    %s:%d' % (file_path, line_num))
 627   return warnings
 628
 629
 630 def _CheckIncludeOrderInFile(input_api, f, changed_linenums):
 631   """Checks the #include order for the given file f."""
 632
 633   system_include_pattern = input_api.re.compile(r'\s*#include \<.*')
 634   # Exclude the following includes from the check:
 635   # 1) #include <.../...>, e.g., <sys/...> includes often need to appear in a
 636   # specific order.
 637   # 2) <atlbase.h>, "build/build_config.h"
 638   excluded_include_pattern = input_api.re.compile(
 639       r'\s*#include (\<.*/.*|\<atlbase\.h\>|"build/build_config.h")')
 640   custom_include_pattern = input_api.re.compile(r'\s*#include "(?P<FILE>.*)"')
 641   # Match the final or penultimate token if it is xxxtest so we can ignore it
 642   # when considering the special first include.
 643   test_file_tag_pattern = input_api.re.compile(
 644     r'_[a-z]+test(?=(_[a-zA-Z0-9]+)?\.)')
 645   if_pattern = input_api.re.compile(
 646       r'\s*#\s*(if|elif|else|endif|define|undef).*')
 647   # Some files need specialized order of includes; exclude such files from this
 648   # check.
 649   uncheckable_includes_pattern = input_api.re.compile(
 650       r'\s*#include '
 651       '("ipc/.*macros\.h"|<windows\.h>|".*gl.*autogen.h")\s*')
 652
 653   contents = f.NewContents()
 654   warnings = []
 655   line_num = 0
 656
 657   # Handle the special first include. If the first include file is
 658   # some/path/file.h, the corresponding including file can be some/path/file.cc,
 659   # some/other/path/file.cc, some/path/file_platform.cc, some/path/file-suffix.h
 660   # etc. It's also possible that no special first include exists.
 661   # If the included file is some/path/file_platform.h the including file could
 662   # also be some/path/file_xxxtest_platform.h.
 663   including_file_base_name = test_file_tag_pattern.sub(
 664     '', input_api.os_path.basename(f.LocalPath()))
 665
 666   for line in contents:
 667     line_num += 1
 668     if system_include_pattern.match(line):
 669       # No special first include -> process the line again along with normal
 670       # includes.
 671       line_num -= 1
 672       break
 673     match = custom_include_pattern.match(line)
 674     if match:
 675       match_dict = match.groupdict()
 676       header_basename = test_file_tag_pattern.sub(
 677         '', input_api.os_path.basename(match_dict['FILE'])).replace('.h', '')
 678
 679       if header_basename not in including_file_base_name:
 680         # No special first include -> process the line again along with normal
 681         # includes.
 682         line_num -= 1
 683       break
 684
 685   # Split into scopes: Each region between #if and #endif is its own scope.
 686   scopes = []
 687   current_scope = []
 688   for line in contents[line_num:]:
 689     line_num += 1
 690     if uncheckable_includes_pattern.match(line):
 691       continue
 692     if if_pattern.match(line):
 693       scopes.append(current_scope)
 694       current_scope = []
 695     elif ((system_include_pattern.match(line) or
 696            custom_include_pattern.match(line)) and
 697           not excluded_include_pattern.match(line)):
 698       current_scope.append((line_num, line))
 699   scopes.append(current_scope)
 700
 701   for scope in scopes:
 702     warnings.extend(_CheckIncludeOrderForScope(scope, input_api, f.LocalPath(),
 703                                                changed_linenums))
 704   return warnings
 705
 706
 707 def _CheckIncludeOrder(input_api, output_api):
 708   """Checks that the #include order is correct.
 709
 710   1. The corresponding header for source files.
 711   2. C system files in alphabetical order
 712   3. C++ system files in alphabetical order
 713   4. Project's .h files in alphabetical order
 714
 715   Each region separated by #if, #elif, #else, #endif, #define and #undef follows
 716   these rules separately.
 717   """
 718
 719   warnings = []
 720   for f in input_api.AffectedFiles():
 721     if f.LocalPath().endswith(('.cc', '.h')):
 722       changed_linenums = set(line_num for line_num, _ in f.ChangedContents())
 723       warnings.extend(_CheckIncludeOrderInFile(input_api, f, changed_linenums))
 724
 725   results = []
 726   if warnings:
 727     results.append(output_api.PresubmitPromptOrNotify(_INCLUDE_ORDER_WARNING,
 728                                                       warnings))
 729   return results
 730
 731
 732 def _CheckForVersionControlConflictsInFile(input_api, f):
 733   pattern = input_api.re.compile('^(?:<<<<<<<|>>>>>>>) |^=======$')
 734   errors = []
 735   for line_num, line in f.ChangedContents():
 736     if pattern.match(line):
 737       errors.append('    %s:%d %s' % (f.LocalPath(), line_num, line))
 738   return errors
 739
 740
 741 def _CheckForVersionControlConflicts(input_api, output_api):
 742   """Usually this is not intentional and will cause a compile failure."""
 743   errors = []
 744   for f in input_api.AffectedFiles():
 745     errors.extend(_CheckForVersionControlConflictsInFile(input_api, f))
 746
 747   results = []
 748   if errors:
 749     results.append(output_api.PresubmitError(
 750       'Version control conflict markers found, please resolve.', errors))
 751   return results
 752
 753
 754 def _CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api):
 755   def FilterFile(affected_file):
 756     """Filter function for use with input_api.AffectedSourceFiles,
 757     below.  This filters out everything except non-test files from
 758     top-level directories that generally speaking should not hard-code
 759     service URLs (e.g. src/android_webview/, src/content/ and others).
 760     """
 761     return input_api.FilterSourceFile(
 762       affected_file,
 763       white_list=(r'^(android_webview|base|content|net)[\\\/].*', ),
 764       black_list=(_EXCLUDED_PATHS +
 765                   _TEST_CODE_EXCLUDED_PATHS +
 766                   input_api.DEFAULT_BLACK_LIST))
 767
 768   base_pattern = '"[^"]*google\.com[^"]*"'
 769   comment_pattern = input_api.re.compile('//.*%s' % base_pattern)
 770   pattern = input_api.re.compile(base_pattern)
 771   problems = []  # items are (filename, line_number, line)
 772   for f in input_api.AffectedSourceFiles(FilterFile):
 773     for line_num, line in f.ChangedContents():
 774       if not comment_pattern.search(line) and pattern.search(line):
 775         problems.append((f.LocalPath(), line_num, line))
 776
 777   if problems:
 778     return [output_api.PresubmitPromptOrNotify(
 779         'Most layers below src/chrome/ should not hardcode service URLs.\n'
 780         'Are you sure this is correct?',
 781         ['  %s:%d:  %s' % (
 782             problem[0], problem[1], problem[2]) for problem in problems])]
 783   else:
 784     return []
 785
 786
 787 def _CheckNoAbbreviationInPngFileName(input_api, output_api):
 788   """Makes sure there are no abbreviations in the name of PNG files.
 789   """
 790   pattern = input_api.re.compile(r'.*_[a-z]_.*\.png$|.*_[a-z]\.png$')
 791   errors = []
 792   for f in input_api.AffectedFiles(include_deletes=False):
 793     if pattern.match(f.LocalPath()):
 794       errors.append('    %s' % f.LocalPath())
 795
 796   results = []
 797   if errors:
 798     results.append(output_api.PresubmitError(
 799         'The name of PNG files should not have abbreviations. \n'
 800         'Use _hover.png, _center.png, instead of _h.png, _c.png.\n'
 801         'Contact oshima@chromium.org if you have questions.', errors))
 802   return results
 803
 804
 805 def _FilesToCheckForIncomingDeps(re, changed_lines):
 806   """Helper method for _CheckAddedDepsHaveTargetApprovals. Returns
 807   a set of DEPS entries that we should look up.
 808
 809   For a directory (rather than a specific filename) we fake a path to
 810   a specific filename by adding /DEPS. This is chosen as a file that
 811   will seldom or never be subject to per-file include_rules.
 812   """
 813   # We ignore deps entries on auto-generated directories.
 814   AUTO_GENERATED_DIRS = ['grit', 'jni']
 815
 816   # This pattern grabs the path without basename in the first
 817   # parentheses, and the basename (if present) in the second. It
 818   # relies on the simple heuristic that if there is a basename it will
 819   # be a header file ending in ".h".
 820   pattern = re.compile(
 821       r"""['"]\+([^'"]+?)(/[a-zA-Z0-9_]+\.h)?['"].*""")
 822   results = set()
 823   for changed_line in changed_lines:
 824     m = pattern.match(changed_line)
 825     if m:
 826       path = m.group(1)
 827       if path.split('/')[0] not in AUTO_GENERATED_DIRS:
 828         if m.group(2):
 829           results.add('%s%s' % (path, m.group(2)))
 830         else:
 831           results.add('%s/DEPS' % path)
 832   return results
 833
 834
 835 def _CheckAddedDepsHaveTargetApprovals(input_api, output_api):
 836   """When a dependency prefixed with + is added to a DEPS file, we
 837   want to make sure that the change is reviewed by an OWNER of the
 838   target file or directory, to avoid layering violations from being
 839   introduced. This check verifies that this happens.
 840   """
 841   changed_lines = set()
 842   for f in input_api.AffectedFiles():
 843     filename = input_api.os_path.basename(f.LocalPath())
 844     if filename == 'DEPS':
 845       changed_lines |= set(line.strip()
 846                            for line_num, line
 847                            in f.ChangedContents())
 848   if not changed_lines:
 849     return []
 850
 851   virtual_depended_on_files = _FilesToCheckForIncomingDeps(input_api.re,
 852                                                            changed_lines)
 853   if not virtual_depended_on_files:
 854     return []
 855
 856   if input_api.is_committing:
 857     if input_api.tbr:
 858       return [output_api.PresubmitNotifyResult(
 859           '--tbr was specified, skipping OWNERS check for DEPS additions')]
 860     if not input_api.change.issue:
 861       return [output_api.PresubmitError(
 862           "DEPS approval by OWNERS check failed: this change has "
 863           "no Rietveld issue number, so we can't check it for approvals.")]
 864     output = output_api.PresubmitError
 865   else:
 866     output = output_api.PresubmitNotifyResult
 867
 868   owners_db = input_api.owners_db
 869   owner_email, reviewers = input_api.canned_checks._RietveldOwnerAndReviewers(
 870       input_api,
 871       owners_db.email_regexp,
 872       approval_needed=input_api.is_committing)
 873
 874   owner_email = owner_email or input_api.change.author_email
 875
 876   reviewers_plus_owner = set(reviewers)
 877   if owner_email:
 878     reviewers_plus_owner.add(owner_email)
 879   missing_files = owners_db.files_not_covered_by(virtual_depended_on_files,
 880                                                  reviewers_plus_owner)
 881
 882   # We strip the /DEPS part that was added by
 883   # _FilesToCheckForIncomingDeps to fake a path to a file in a
 884   # directory.
 885   def StripDeps(path):
 886     start_deps = path.rfind('/DEPS')
 887     if start_deps != -1:
 888       return path[:start_deps]
 889     else:
 890       return path
 891   unapproved_dependencies = ["'+%s'," % StripDeps(path)
 892                              for path in missing_files]
 893
 894   if unapproved_dependencies:
 895     output_list = [
 896       output('Missing LGTM from OWNERS of dependencies added to DEPS:\n    %s' %
 897              '\n    '.join(sorted(unapproved_dependencies)))]
 898     if not input_api.is_committing:
 899       suggested_owners = owners_db.reviewers_for(missing_files, owner_email)
 900       output_list.append(output(
 901           'Suggested missing target path OWNERS:\n    %s' %
 902           '\n    '.join(suggested_owners or [])))
 903     return output_list
 904
 905   return []
 906
 907
 908 def _CheckSpamLogging(input_api, output_api):
 909   file_inclusion_pattern = r'.+%s' % _IMPLEMENTATION_EXTENSIONS
 910   black_list = (_EXCLUDED_PATHS +
 911                 _TEST_CODE_EXCLUDED_PATHS +
 912                 input_api.DEFAULT_BLACK_LIST +
 913                 (r"^base[\\\/]logging\.h$",
 914                  r"^base[\\\/]logging\.cc$",
 915                  r"^cloud_print[\\\/]",
 916                  r"^chrome_elf[\\\/]dll_hash[\\\/]dll_hash_main\.cc$",
 917                  r"^chrome[\\\/]app[\\\/]chrome_main_delegate\.cc$",
 918                  r"^chrome[\\\/]browser[\\\/]chrome_browser_main\.cc$",
 919                  r"^chrome[\\\/]browser[\\\/]ui[\\\/]startup[\\\/]"
 920                      r"startup_browser_creator\.cc$",
 921                  r"^chrome[\\\/]installer[\\\/]setup[\\\/].*",
 922                  r"^extensions[\\\/]renderer[\\\/]logging_native_handler\.cc$",
 923                  r"^content[\\\/]common[\\\/]gpu[\\\/]client[\\\/]"
 924                      r"gl_helper_benchmark\.cc$",
 925                  r"^native_client_sdk[\\\/]",
 926                  r"^remoting[\\\/]base[\\\/]logging\.h$",
 927                  r"^remoting[\\\/]host[\\\/].*",
 928                  r"^sandbox[\\\/]linux[\\\/].*",
 929                  r"^tools[\\\/]",
 930                  r"^ui[\\\/]aura[\\\/]bench[\\\/]bench_main\.cc$",))
 931   source_file_filter = lambda x: input_api.FilterSourceFile(
 932       x, white_list=(file_inclusion_pattern,), black_list=black_list)
 933
 934   log_info = []
 935   printf = []
 936
 937   for f in input_api.AffectedSourceFiles(source_file_filter):
 938     contents = input_api.ReadFile(f, 'rb')
 939     if re.search(r"\bD?LOG\s*\(\s*INFO\s*\)", contents):
 940       log_info.append(f.LocalPath())
 941     elif re.search(r"\bD?LOG_IF\s*\(\s*INFO\s*,", contents):
 942       log_info.append(f.LocalPath())
 943
 944     if re.search(r"\bprintf\(", contents):
 945       printf.append(f.LocalPath())
 946     elif re.search(r"\bfprintf\((stdout|stderr)", contents):
 947       printf.append(f.LocalPath())
 948
 949   if log_info:
 950     return [output_api.PresubmitError(
 951       'These files spam the console log with LOG(INFO):',
 952       items=log_info)]
 953   if printf:
 954     return [output_api.PresubmitError(
 955       'These files spam the console log with printf/fprintf:',
 956       items=printf)]
 957   return []
 958
 959
 960 def _CheckForAnonymousVariables(input_api, output_api):
 961   """These types are all expected to hold locks while in scope and
 962      so should never be anonymous (which causes them to be immediately
 963      destroyed)."""
 964   they_who_must_be_named = [
 965     'base::AutoLock',
 966     'base::AutoReset',
 967     'base::AutoUnlock',
 968     'SkAutoAlphaRestore',
 969     'SkAutoBitmapShaderInstall',
 970     'SkAutoBlitterChoose',
 971     'SkAutoBounderCommit',
 972     'SkAutoCallProc',
 973     'SkAutoCanvasRestore',
 974     'SkAutoCommentBlock',
 975     'SkAutoDescriptor',
 976     'SkAutoDisableDirectionCheck',
 977     'SkAutoDisableOvalCheck',
 978     'SkAutoFree',
 979     'SkAutoGlyphCache',
 980     'SkAutoHDC',
 981     'SkAutoLockColors',
 982     'SkAutoLockPixels',
 983     'SkAutoMalloc',
 984     'SkAutoMaskFreeImage',
 985     'SkAutoMutexAcquire',
 986     'SkAutoPathBoundsUpdate',
 987     'SkAutoPDFRelease',
 988     'SkAutoRasterClipValidate',
 989     'SkAutoRef',
 990     'SkAutoTime',
 991     'SkAutoTrace',
 992     'SkAutoUnref',
 993   ]
 994   anonymous = r'(%s)\s*[({]' % '|'.join(they_who_must_be_named)
 995   # bad: base::AutoLock(lock.get());
 996   # not bad: base::AutoLock lock(lock.get());
 997   bad_pattern = input_api.re.compile(anonymous)
 998   # good: new base::AutoLock(lock.get())
 999   good_pattern = input_api.re.compile(r'\bnew\s*' + anonymous)
1000   errors = []
1001
1002   for f in input_api.AffectedFiles():
1003     if not f.LocalPath().endswith(('.cc', '.h', '.inl', '.m', '.mm')):
1004       continue
1005     for linenum, line in f.ChangedContents():
1006       if bad_pattern.search(line) and not good_pattern.search(line):
1007         errors.append('%s:%d' % (f.LocalPath(), linenum))
1008
1009   if errors:
1010     return [output_api.PresubmitError(
1011       'These lines create anonymous variables that need to be named:',
1012       items=errors)]
1013   return []
1014
1015
1016 def _CheckCygwinShell(input_api, output_api):
1017   source_file_filter = lambda x: input_api.FilterSourceFile(
1018       x, white_list=(r'.+\.(gyp|gypi)$',))
1019   cygwin_shell = []
1020
1021   for f in input_api.AffectedSourceFiles(source_file_filter):
1022     for linenum, line in f.ChangedContents():
1023       if 'msvs_cygwin_shell' in line:
1024         cygwin_shell.append(f.LocalPath())
1025         break
1026
1027   if cygwin_shell:
1028     return [output_api.PresubmitError(
1029       'These files should not use msvs_cygwin_shell (the default is 0):',
1030       items=cygwin_shell)]
1031   return []
1032
1033
1034 def _CheckUserActionUpdate(input_api, output_api):
1035   """Checks if any new user action has been added."""
1036   if any('actions.xml' == input_api.os_path.basename(f) for f in
1037          input_api.LocalPaths()):
1038     # If actions.xml is already included in the changelist, the PRESUBMIT
1039     # for actions.xml will do a more complete presubmit check.
1040     return []
1041
1042   file_filter = lambda f: f.LocalPath().endswith(('.cc', '.mm'))
1043   action_re = r'[^a-zA-Z]UserMetricsAction\("([^"]*)'
1044   current_actions = None
1045   for f in input_api.AffectedFiles(file_filter=file_filter):
1046     for line_num, line in f.ChangedContents():
1047       match = input_api.re.search(action_re, line)
1048       if match:
1049         # Loads contents in tools/metrics/actions/actions.xml to memory. It's
1050         # loaded only once.
1051         if not current_actions:
1052           with open('tools/metrics/actions/actions.xml') as actions_f:
1053             current_actions = actions_f.read()
1054         # Search for the matched user action name in |current_actions|.
1055         for action_name in match.groups():
1056           action = 'name="{0}"'.format(action_name)
1057           if action not in current_actions:
1058             return [output_api.PresubmitPromptWarning(
1059               'File %s line %d: %s is missing in '
1060               'tools/metrics/actions/actions.xml. Please run '
1061               'tools/metrics/actions/extract_actions.py to update.'
1062               % (f.LocalPath(), line_num, action_name))]
1063   return []
1064
1065
1066 def _CheckJavaStyle(input_api, output_api):
1067   """Runs checkstyle on changed java files and returns errors if any exist."""
1068   original_sys_path = sys.path
1069   try:
1070     sys.path = sys.path + [input_api.os_path.join(
1071         input_api.PresubmitLocalPath(), 'tools', 'android', 'checkstyle')]
1072     import checkstyle
1073   finally:
1074     # Restore sys.path to what it was before.
1075     sys.path = original_sys_path
1076
1077   return checkstyle.RunCheckstyle(
1078       input_api, output_api, 'tools/android/checkstyle/chromium-style-5.0.xml')
1079
1080
1081 _DEPRECATED_CSS = [
1082   # Values
1083   ( "-webkit-box", "flex" ),
1084   ( "-webkit-inline-box", "inline-flex" ),
1085   ( "-webkit-flex", "flex" ),
1086   ( "-webkit-inline-flex", "inline-flex" ),
1087   ( "-webkit-min-content", "min-content" ),
1088   ( "-webkit-max-content", "max-content" ),
1089
1090   # Properties
1091   ( "-webkit-background-clip", "background-clip" ),
1092   ( "-webkit-background-origin", "background-origin" ),
1093   ( "-webkit-background-size", "background-size" ),
1094   ( "-webkit-box-shadow", "box-shadow" ),
1095
1096   # Functions
1097   ( "-webkit-gradient", "gradient" ),
1098   ( "-webkit-repeating-gradient", "repeating-gradient" ),
1099   ( "-webkit-linear-gradient", "linear-gradient" ),
1100   ( "-webkit-repeating-linear-gradient", "repeating-linear-gradient" ),
1101   ( "-webkit-radial-gradient", "radial-gradient" ),
1102   ( "-webkit-repeating-radial-gradient", "repeating-radial-gradient" ),
1103 ]
1104
1105 def _CheckNoDeprecatedCSS(input_api, output_api):
1106   """ Make sure that we don't use deprecated CSS
1107       properties, functions or values. """
1108   results = []
1109   file_filter = lambda f: f.LocalPath().endswith('.css')
1110   for fpath in input_api.AffectedFiles(file_filter=file_filter):
1111     for line_num, line in fpath.ChangedContents():
1112       for (deprecated_value, value) in _DEPRECATED_CSS:
1113         if input_api.re.search(deprecated_value, line):
1114           results.append(output_api.PresubmitError(
1115               "%s:%d: Use of deprecated CSS %s, use %s instead" %
1116               (fpath.LocalPath(), line_num, deprecated_value, value)))
1117   return results
1118
1119 def _CommonChecks(input_api, output_api):
1120   """Checks common to both upload and commit."""
1121   results = []
1122   results.extend(input_api.canned_checks.PanProjectChecks(
1123       input_api, output_api,
1124       excluded_paths=_EXCLUDED_PATHS + _TESTRUNNER_PATHS))
1125   results.extend(_CheckAuthorizedAuthor(input_api, output_api))
1126   results.extend(
1127       _CheckNoProductionCodeUsingTestOnlyFunctions(input_api, output_api))
1128   results.extend(_CheckNoIOStreamInHeaders(input_api, output_api))
1129   results.extend(_CheckNoUNIT_TESTInSourceFiles(input_api, output_api))
1130   results.extend(_CheckNoNewWStrings(input_api, output_api))
1131   results.extend(_CheckNoDEPSGIT(input_api, output_api))
1132   results.extend(_CheckNoBannedFunctions(input_api, output_api))
1133   results.extend(_CheckNoPragmaOnce(input_api, output_api))
1134   results.extend(_CheckNoTrinaryTrueFalse(input_api, output_api))
1135   results.extend(_CheckUnwantedDependencies(input_api, output_api))
1136   results.extend(_CheckFilePermissions(input_api, output_api))
1137   results.extend(_CheckNoAuraWindowPropertyHInHeaders(input_api, output_api))
1138   results.extend(_CheckIncludeOrder(input_api, output_api))
1139   results.extend(_CheckForVersionControlConflicts(input_api, output_api))
1140   results.extend(_CheckPatchFiles(input_api, output_api))
1141   results.extend(_CheckHardcodedGoogleHostsInLowerLayers(input_api, output_api))
1142   results.extend(_CheckNoAbbreviationInPngFileName(input_api, output_api))
1143   results.extend(_CheckForInvalidOSMacros(input_api, output_api))
1144   results.extend(_CheckAddedDepsHaveTargetApprovals(input_api, output_api))
1145   results.extend(
1146       input_api.canned_checks.CheckChangeHasNoTabs(
1147           input_api,
1148           output_api,
1149           source_file_filter=lambda x: x.LocalPath().endswith('.grd')))
1150   results.extend(_CheckSpamLogging(input_api, output_api))
1151   results.extend(_CheckForAnonymousVariables(input_api, output_api))
1152   results.extend(_CheckCygwinShell(input_api, output_api))
1153   results.extend(_CheckUserActionUpdate(input_api, output_api))
1154   results.extend(_CheckNoDeprecatedCSS(input_api, output_api))
1155
1156   if any('PRESUBMIT.py' == f.LocalPath() for f in input_api.AffectedFiles()):
1157     results.extend(input_api.canned_checks.RunUnitTestsInDirectory(
1158         input_api, output_api,
1159         input_api.PresubmitLocalPath(),
1160         whitelist=[r'^PRESUBMIT_test\.py$']))
1161   return results
1162
1163
1164 def _CheckSubversionConfig(input_api, output_api):
1165   """Verifies the subversion config file is correctly setup.
1166
1167   Checks that autoprops are enabled, returns an error otherwise.
1168   """
1169   join = input_api.os_path.join
1170   if input_api.platform == 'win32':
1171     appdata = input_api.environ.get('APPDATA', '')
1172     if not appdata:
1173       return [output_api.PresubmitError('%APPDATA% is not configured.')]
1174     path = join(appdata, 'Subversion', 'config')
1175   else:
1176     home = input_api.environ.get('HOME', '')
1177     if not home:
1178       return [output_api.PresubmitError('$HOME is not configured.')]
1179     path = join(home, '.subversion', 'config')
1180
1181   error_msg = (
1182       'Please look at http://dev.chromium.org/developers/coding-style to\n'
1183       'configure your subversion configuration file. This enables automatic\n'
1184       'properties to simplify the project maintenance.\n'
1185       'Pro-tip: just download and install\n'
1186       'http://src.chromium.org/viewvc/chrome/trunk/tools/build/slave/config\n')
1187
1188   try:
1189     lines = open(path, 'r').read().splitlines()
1190     # Make sure auto-props is enabled and check for 2 Chromium standard
1191     # auto-prop.
1192     if (not '*.cc = svn:eol-style=LF' in lines or
1193         not '*.pdf = svn:mime-type=application/pdf' in lines or
1194         not 'enable-auto-props = yes' in lines):
1195       return [
1196           output_api.PresubmitNotifyResult(
1197               'It looks like you have not configured your subversion config '
1198               'file or it is not up-to-date.\n' + error_msg)
1199       ]
1200   except (OSError, IOError):
1201     return [
1202         output_api.PresubmitNotifyResult(
1203             'Can\'t find your subversion config file.\n' + error_msg)
1204     ]
1205   return []
1206
1207
1208 def _CheckAuthorizedAuthor(input_api, output_api):
1209   """For non-googler/chromites committers, verify the author's email address is
1210   in AUTHORS.
1211   """
1212   # TODO(maruel): Add it to input_api?
1213   import fnmatch
1214
1215   author = input_api.change.author_email
1216   if not author:
1217     input_api.logging.info('No author, skipping AUTHOR check')
1218     return []
1219   authors_path = input_api.os_path.join(
1220       input_api.PresubmitLocalPath(), 'AUTHORS')
1221   valid_authors = (
1222       input_api.re.match(r'[^#]+\s+\<(.+?)\>\s*$', line)
1223       for line in open(authors_path))
1224   valid_authors = [item.group(1).lower() for item in valid_authors if item]
1225   if not any(fnmatch.fnmatch(author.lower(), valid) for valid in valid_authors):
1226     input_api.logging.info('Valid authors are %s', ', '.join(valid_authors))
1227     return [output_api.PresubmitPromptWarning(
1228         ('%s is not in AUTHORS file. If you are a new contributor, please visit'
1229         '\n'
1230         'http://www.chromium.org/developers/contributing-code and read the '
1231         '"Legal" section\n'
1232         'If you are a chromite, verify the contributor signed the CLA.') %
1233         author)]
1234   return []
1235
1236
1237 def _CheckPatchFiles(input_api, output_api):
1238   problems = [f.LocalPath() for f in input_api.AffectedFiles()
1239       if f.LocalPath().endswith(('.orig', '.rej'))]
1240   if problems:
1241     return [output_api.PresubmitError(
1242         "Don't commit .rej and .orig files.", problems)]
1243   else:
1244     return []
1245
1246
1247 def _DidYouMeanOSMacro(bad_macro):
1248   try:
1249     return {'A': 'OS_ANDROID',
1250             'B': 'OS_BSD',
1251             'C': 'OS_CHROMEOS',
1252             'F': 'OS_FREEBSD',
1253             'L': 'OS_LINUX',
1254             'M': 'OS_MACOSX',
1255             'N': 'OS_NACL',
1256             'O': 'OS_OPENBSD',
1257             'P': 'OS_POSIX',
1258             'S': 'OS_SOLARIS',
1259             'W': 'OS_WIN'}[bad_macro[3].upper()]
1260   except KeyError:
1261     return ''
1262
1263
1264 def _CheckForInvalidOSMacrosInFile(input_api, f):
1265   """Check for sensible looking, totally invalid OS macros."""
1266   preprocessor_statement = input_api.re.compile(r'^\s*#')
1267   os_macro = input_api.re.compile(r'defined\((OS_[^)]+)\)')
1268   results = []
1269   for lnum, line in f.ChangedContents():
1270     if preprocessor_statement.search(line):
1271       for match in os_macro.finditer(line):
1272         if not match.group(1) in _VALID_OS_MACROS:
1273           good = _DidYouMeanOSMacro(match.group(1))
1274           did_you_mean = ' (did you mean %s?)' % good if good else ''
1275           results.append('    %s:%d %s%s' % (f.LocalPath(),
1276                                              lnum,
1277                                              match.group(1),
1278                                              did_you_mean))
1279   return results
1280
1281
1282 def _CheckForInvalidOSMacros(input_api, output_api):
1283   """Check all affected files for invalid OS macros."""
1284   bad_macros = []
1285   for f in input_api.AffectedFiles():
1286     if not f.LocalPath().endswith(('.py', '.js', '.html', '.css')):
1287       bad_macros.extend(_CheckForInvalidOSMacrosInFile(input_api, f))
1288
1289   if not bad_macros:
1290     return []
1291
1292   return [output_api.PresubmitError(
1293       'Possibly invalid OS macro[s] found. Please fix your code\n'
1294       'or add your macro to src/PRESUBMIT.py.', bad_macros)]
1295
1296
1297 def CheckChangeOnUpload(input_api, output_api):
1298   results = []
1299   results.extend(_CommonChecks(input_api, output_api))
1300   results.extend(_CheckJavaStyle(input_api, output_api))
1301   return results
1302
1303
1304 def GetTryServerMasterForBot(bot):
1305   """Returns the Try Server master for the given bot.
1306
1307   Assumes that most Try Servers are on the tryserver.chromium master."""
1308   non_default_master_map = {
1309       'linux_gpu': 'tryserver.chromium.gpu',
1310       'mac_gpu': 'tryserver.chromium.gpu',
1311       'win_gpu': 'tryserver.chromium.gpu',
1312   }
1313   return non_default_master_map.get(bot, 'tryserver.chromium')
1314
1315
1316 def GetDefaultTryConfigs(bots=None):
1317   """Returns a list of ('bot', set(['tests']), optionally filtered by [bots].
1318
1319   To add tests to this list, they MUST be in the the corresponding master's
1320   gatekeeper config. For example, anything on master.chromium would be closed by
1321   tools/build/masters/master.chromium/master_gatekeeper_cfg.py.
1322
1323   If 'bots' is specified, will only return configurations for bots in that list.
1324   """
1325
1326   standard_tests = [
1327       'base_unittests',
1328       'browser_tests',
1329       'cacheinvalidation_unittests',
1330       'check_deps',
1331       'check_deps2git',
1332       'content_browsertests',
1333       'content_unittests',
1334       'crypto_unittests',
1335       'gpu_unittests',
1336       'interactive_ui_tests',
1337       'ipc_tests',
1338       'jingle_unittests',
1339       'media_unittests',
1340       'net_unittests',
1341       'ppapi_unittests',
1342       'printing_unittests',
1343       'sql_unittests',
1344       'sync_unit_tests',
1345       'unit_tests',
1346       # Broken in release.
1347       #'url_unittests',
1348       #'webkit_unit_tests',
1349   ]
1350
1351   builders_and_tests = {
1352       # TODO(maruel): Figure out a way to run 'sizes' where people can
1353       # effectively update the perf expectation correctly.  This requires a
1354       # clobber=True build running 'sizes'. 'sizes' is not accurate with
1355       # incremental build. Reference:
1356       # http://chromium.org/developers/tree-sheriffs/perf-sheriffs.
1357       # TODO(maruel): An option would be to run 'sizes' but not count a failure
1358       # of this step as a try job failure.
1359       'android_aosp': ['compile'],
1360       'android_chromium_gn_compile_rel': ['compile'],
1361       'android_clang_dbg': ['slave_steps'],
1362       'android_dbg': ['slave_steps'],
1363       'cros_x86': ['defaulttests'],
1364       'ios_dbg_simulator': [
1365           'compile',
1366           'base_unittests',
1367           'content_unittests',
1368           'crypto_unittests',
1369           'url_unittests',
1370           'net_unittests',
1371           'sql_unittests',
1372           'ui_unittests',
1373       ],
1374       'ios_rel_device': ['compile'],
1375       'linux_asan': ['compile'],
1376       'mac_asan': ['compile'],
1377       #TODO(stip): Change the name of this builder to reflect that it's release.
1378       'linux_gtk': standard_tests,
1379       'linux_chromeos_asan': ['compile'],
1380       'linux_chromium_chromeos_clang_dbg': ['defaulttests'],
1381       'linux_chromium_chromeos_rel': ['defaulttests'],
1382       'linux_chromium_compile_dbg': ['defaulttests'],
1383       'linux_chromium_gn_rel': ['defaulttests'],
1384       'linux_chromium_rel': ['defaulttests'],
1385       'linux_chromium_clang_dbg': ['defaulttests'],
1386       'linux_gpu': ['defaulttests'],
1387       'linux_nacl_sdk_build': ['compile'],
1388       'linux_rel': [
1389           'telemetry_perf_unittests',
1390           'telemetry_unittests',
1391       ],
1392       'mac_chromium_compile_dbg': ['defaulttests'],
1393       'mac_chromium_rel': ['defaulttests'],
1394       'mac_gpu': ['defaulttests'],
1395       'mac_nacl_sdk_build': ['compile'],
1396       'mac_rel': [
1397           'telemetry_perf_unittests',
1398           'telemetry_unittests',
1399       ],
1400       'win': ['compile'],
1401       'win_chromium_compile_dbg': ['defaulttests'],
1402       'win_chromium_dbg': ['defaulttests'],
1403       'win_chromium_rel': ['defaulttests'],
1404       'win_chromium_x64_rel': ['defaulttests'],
1405       'win_gpu': ['defaulttests'],
1406       'win_nacl_sdk_build': ['compile'],
1407       'win_rel': standard_tests + [
1408           'app_list_unittests',
1409           'ash_unittests',
1410           'aura_unittests',
1411           'cc_unittests',
1412           'chrome_elf_unittests',
1413           'chromedriver_unittests',
1414           'components_unittests',
1415           'compositor_unittests',
1416           'events_unittests',
1417           'gfx_unittests',
1418           'google_apis_unittests',
1419           'installer_util_unittests',
1420           'mini_installer_test',
1421           'nacl_integration',
1422           'remoting_unittests',
1423           'sync_integration_tests',
1424           'telemetry_perf_unittests',
1425           'telemetry_unittests',
1426           'views_unittests',
1427       ],
1428       'win_x64_rel': [
1429           'base_unittests',
1430       ],
1431   }
1432
1433   swarm_enabled_builders = (
1434   # http://crbug.com/354263
1435   #    'linux_rel',
1436   #    'mac_rel',
1437   #    'win_rel',
1438   )
1439
1440   swarm_enabled_tests = (
1441       'base_unittests',
1442       'browser_tests',
1443       'interactive_ui_tests',
1444       'net_unittests',
1445       'unit_tests',
1446   )
1447
1448   for bot in builders_and_tests:
1449     if bot in swarm_enabled_builders:
1450       builders_and_tests[bot] = [x + '_swarm' if x in swarm_enabled_tests else x
1451                                  for x in builders_and_tests[bot]]
1452
1453   if bots:
1454     filtered_builders_and_tests = dict((bot, set(builders_and_tests[bot]))
1455                                        for bot in bots)
1456   else:
1457     filtered_builders_and_tests = dict(
1458         (bot, set(tests))
1459         for bot, tests in builders_and_tests.iteritems())
1460
1461   # Build up the mapping from tryserver master to bot/test.
1462   out = dict()
1463   for bot, tests in filtered_builders_and_tests.iteritems():
1464     out.setdefault(GetTryServerMasterForBot(bot), {})[bot] = tests
1465   return out
1466
1467
1468 def CheckChangeOnCommit(input_api, output_api):
1469   results = []
1470   results.extend(_CommonChecks(input_api, output_api))
1471   # TODO(thestig) temporarily disabled, doesn't work in third_party/
1472   #results.extend(input_api.canned_checks.CheckSvnModifiedDirectories(
1473   #    input_api, output_api, sources))
1474   # Make sure the tree is 'open'.
1475   results.extend(input_api.canned_checks.CheckTreeIsOpen(
1476       input_api,
1477       output_api,
1478       json_url='http://chromium-status.appspot.com/current?format=json'))
1479
1480   results.extend(input_api.canned_checks.CheckChangeHasBugField(
1481       input_api, output_api))
1482   results.extend(input_api.canned_checks.CheckChangeHasDescription(
1483       input_api, output_api))
1484   results.extend(_CheckSubversionConfig(input_api, output_api))
1485   return results
1486
1487
1488 def GetPreferredTryMasters(project, change):
1489   files = change.LocalPaths()
1490
1491   if not files or all(re.search(r'[\\/]OWNERS$', f) for f in files):
1492     return {}
1493
1494   if all(re.search('\.(m|mm)$|(^|[/_])mac[/_.]', f) for f in files):
1495     return GetDefaultTryConfigs([
1496         'mac_chromium_compile_dbg',
1497         'mac_chromium_rel',
1498     ])
1499   if all(re.search('(^|[/_])win[/_.]', f) for f in files):
1500     return GetDefaultTryConfigs(['win_chromium_dbg', 'win_chromium_rel'])
1501   if all(re.search('(^|[/_])android[/_.]', f) for f in files):
1502     return GetDefaultTryConfigs([
1503         'android_aosp',
1504         'android_clang_dbg',
1505         'android_dbg',
1506     ])
1507   if all(re.search('[/_]ios[/_.]', f) for f in files):
1508     return GetDefaultTryConfigs(['ios_rel_device', 'ios_dbg_simulator'])
1509
1510   builders = [
1511       'android_chromium_gn_compile_rel',
1512       'android_clang_dbg',
1513       'android_dbg',
1514       'ios_dbg_simulator',
1515       'ios_rel_device',
1516       'linux_chromium_chromeos_rel',
1517       'linux_chromium_clang_dbg',
1518       'linux_chromium_gn_rel',
1519       'linux_chromium_rel',
1520       'linux_gpu',
1521       'mac_chromium_compile_dbg',
1522       'mac_chromium_rel',
1523       'mac_gpu',
1524       'win_chromium_compile_dbg',
1525       'win_chromium_rel',
1526       'win_chromium_x64_rel',
1527       'win_gpu',
1528   ]
1529
1530   # Match things like path/aura/file.cc and path/file_aura.cc.
1531   # Same for chromeos.
1532   if any(re.search('[/_](aura|chromeos)', f) for f in files):
1533     builders.extend([
1534         'linux_chromeos_asan',
1535         'linux_chromium_chromeos_clang_dbg'
1536     ])
1537
1538   # If there are gyp changes to base, build, or chromeos, run a full cros build
1539   # in addition to the shorter linux_chromeos build. Changes to high level gyp
1540   # files have a much higher chance of breaking the cros build, which is
1541   # differnt from the linux_chromeos build that most chrome developers test
1542   # with.
1543   if any(re.search('^(base|build|chromeos).*\.gypi?$', f) for f in files):
1544     builders.extend(['cros_x86'])
1545
1546   # The AOSP bot doesn't build the chrome/ layer, so ignore any changes to it
1547   # unless they're .gyp(i) files as changes to those files can break the gyp
1548   # step on that bot.
1549   if (not all(re.search('^chrome', f) for f in files) or
1550       any(re.search('\.gypi?$', f) for f in files)):
1551     builders.extend(['android_aosp'])
1552
1553   return GetDefaultTryConfigs(builders)