Configure components/viz/ directory.

components/viz/PRESUBMIT.py

-# Copyright (c) 2012 The Chromium Authors. All rights reserved.
+# Copyright 2017 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""Top-level presubmit script for cc.
+"""Top-level presubmit script for components/viz.
 
 See http://dev.chromium.org/developers/how-tos/depottools/presubmit-scripts
 for more details about the presubmit API built into depot_tools.
 """
 
 import re
 import string
 
-CC_SOURCE_FILES=(r'^cc[\\/].*\.(cc|h)$',)
+VIZ_SOURCE_FILES=(r'^components[\\/]viz[\\/].*\.(cc|h)$',)
 
 def CheckChangeLintsClean(input_api, output_api):
   source_filter = lambda x: input_api.FilterSourceFile(
-    x, white_list=CC_SOURCE_FILES, black_list=None)
+    x, white_list=VIZ_SOURCE_FILES, black_list=None)
 
   return input_api.canned_checks.CheckChangeLintsClean(
       input_api, output_api, source_filter, lint_filters=[], verbose_level=1)
 
-def CheckAsserts(input_api, output_api, white_list=CC_SOURCE_FILES, black_list=None):
+def CheckAsserts(input_api, output_api, white_list=VIZ_SOURCE_FILES, black_list=None):
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   source_file_filter = lambda x: input_api.FilterSourceFile(x, white_list, black_list)
 
   assert_files = []
-  notreached_files = []
 
   for f in input_api.AffectedSourceFiles(source_file_filter):
     contents = input_api.ReadFile(f, 'rb')
     # WebKit ASSERT() is not allowed.
     if re.search(r"\bASSERT\(", contents):
       assert_files.append(f.LocalPath())
-    # WebKit ASSERT_NOT_REACHED() is not allowed.
-    if re.search(r"ASSERT_NOT_REACHED\(", contents):
-      notreached_files.append(f.LocalPath())
 
   if assert_files:
     return [output_api.PresubmitError(
       'These files use ASSERT instead of using DCHECK:',
       items=assert_files)]
-  if notreached_files:
-    return [output_api.PresubmitError(
-      'These files use ASSERT_NOT_REACHED instead of using NOTREACHED:',
-      items=notreached_files)]
   return []
 
 def CheckStdAbs(input_api, output_api,
-                white_list=CC_SOURCE_FILES, black_list=None):
+                white_list=VIZ_SOURCE_FILES, black_list=None):
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   source_file_filter = lambda x: input_api.FilterSourceFile(x,
                                                             white_list,
                                                             black_list)
 
   using_std_abs_files = []
   found_fabs_files = []
   missing_std_prefix_files = []
 
   for f in input_api.AffectedSourceFiles(source_file_filter):
@@ skipping 26 matching lines @@
         items=found_fabs_files))
   if missing_std_prefix_files:
     result.append(output_api.PresubmitError(
         'These files use abs(), absf(), fabs(), or fabsf() without qualifying '
         'the std namespace. Please use std::abs() in all places.',
         items=missing_std_prefix_files))
   return result
 
 def CheckPassByValue(input_api,
                      output_api,
-                     white_list=CC_SOURCE_FILES,
+                     white_list=VIZ_SOURCE_FILES,
                      black_list=None):
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   source_file_filter = lambda x: input_api.FilterSourceFile(x,
                                                             white_list,
                                                             black_list)
 
   local_errors = []
 
-  # Well-defined simple classes containing only <= 4 ints, or <= 2 floats.
+  # Well-defined simple classes the same size as a primitive type.
   pass_by_value_types = ['base::Time',
                          'base::TimeTicks',
                          ]
 
   for f in input_api.AffectedSourceFiles(source_file_filter):
     contents = input_api.ReadFile(f, 'rb')
     match = re.search(
       r'\bconst +' + '(?P<type>(%s))&' %
         string.join(pass_by_value_types, '|'),
       contents)
     if match:
       local_errors.append(output_api.PresubmitError(
         '%s passes %s by const ref instead of by value.' %
         (f.LocalPath(), match.group('type'))))
   return local_errors
 
 def CheckTodos(input_api, output_api):
   errors = []
 
   source_file_filter = lambda x: x
   for f in input_api.AffectedSourceFiles(source_file_filter):
     contents = input_api.ReadFile(f, 'rb')
     if ('FIX'+'ME') in contents:
       errors.append(f.LocalPath())
 
   if errors:
     return [output_api.PresubmitError(
-      'All TODO comments should be of the form TODO(name). ' +
+      'All TODO comments should be of the form TODO(name/bug). ' +
       'Use TODO instead of FIX' + 'ME',
       items=errors)]
   return []
 
-def CheckDoubleAngles(input_api, output_api, white_list=CC_SOURCE_FILES,
+def CheckDoubleAngles(input_api, output_api, white_list=VIZ_SOURCE_FILES,
                       black_list=None):
   errors = []
 
   source_file_filter = lambda x: input_api.FilterSourceFile(x,
                                                             white_list,
                                                             black_list)
   for f in input_api.AffectedSourceFiles(source_file_filter):
     contents = input_api.ReadFile(f, 'rb')
     if ('> >') in contents:
       errors.append(f.LocalPath())
 
   if errors:
     return [output_api.PresubmitError('Use >> instead of > >:', items=errors)]
   return []
 
 def CheckUniquePtr(input_api, output_api,
-                   white_list=CC_SOURCE_FILES, black_list=None):
+                   white_list=VIZ_SOURCE_FILES, black_list=None):
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   source_file_filter = lambda x: input_api.FilterSourceFile(x,
                                                             white_list,
                                                             black_list)
   errors = []
   for f in input_api.AffectedSourceFiles(source_file_filter):
     for line_number, line in f.ChangedContents():
       # Disallow:
       # return std::unique_ptr<T>(foo);
       # bar = std::unique_ptr<T>(foo);
@@ skipping 64 matching lines @@
       in_whitelist = False
       for w in whitelist:
         if re.match(w, contents[next:]):
           in_whitelist = True
           break
       if not in_whitelist:
         return True
     pos = next + 1
   return False
 
-# Checks for the use of cc:: within the cc namespace, which is usually
+# Checks for the use of viz:: within the viz namespace, which is usually
 # redundant.
 def CheckNamespace(input_api, output_api):
   errors = []
 
   source_file_filter = lambda x: x
   for f in input_api.AffectedSourceFiles(source_file_filter):
     contents = input_api.ReadFile(f, 'rb')
-    match = re.search(r'namespace\s*cc\s*{', contents)
+    match = re.search(r'namespace\s*viz\s*{', contents)
     if match:
       whitelist = []
-      if FindNamespaceInBlock(match.end(), 'cc', contents, whitelist=whitelist):
+      if FindNamespaceInBlock(match.end(), 'viz', contents, whitelist=whitelist):
         errors.append(f.LocalPath())
 
   if errors:
     return [output_api.PresubmitError(
-      'Do not use cc:: inside of the cc namespace.',
+      'Do not use viz:: inside of the viz namespace.',
       items=errors)]
   return []
 
 def CheckForUseOfWrongClock(input_api,
                             output_api,
-                            white_list=CC_SOURCE_FILES,
+                            white_list=VIZ_SOURCE_FILES,
                             black_list=None):
   """Make sure new lines of code don't use a clock susceptible to skew."""
   black_list = tuple(black_list or input_api.DEFAULT_BLACK_LIST)
   source_file_filter = lambda x: input_api.FilterSourceFile(x,
                                                             white_list,
                                                             black_list)
   # Regular expression that should detect any explicit references to the
   # base::Time type (or base::Clock/DefaultClock), whether in using decls,
   # typedefs, or to call static methods.
   base_time_type_pattern = r'(^|\W)base::(Time|Clock|DefaultClock)(\W|$)'
@@ skipping 43 matching lines @@
   results += CheckStdAbs(input_api, output_api)
   results += CheckPassByValue(input_api, output_api)
   results += CheckChangeLintsClean(input_api, output_api)
   results += CheckTodos(input_api, output_api)
   results += CheckDoubleAngles(input_api, output_api)
   results += CheckUniquePtr(input_api, output_api)
   results += CheckNamespace(input_api, output_api)
   results += CheckForUseOfWrongClock(input_api, output_api)
   results += FindUselessIfdefs(input_api, output_api)
   return results
-
-def PostUploadHook(cl, change, output_api):
-  """git cl upload will call this hook after the issue is created/modified.
-
-  This hook adds an extra try bot list to the CL description in order to run
-  Blink tests in addition to the CQ try bots.
-  """
-  return output_api.EnsureCQIncludeTrybotsAreAdded(
-    cl,
-    ['master.tryserver.blink:linux_trusty_blink_rel'],
-    'Automatically added Blink trybots to run Blink tests on CQ.')