Allow move_source_file.py and sort-headers.py to work on blink.

tools/sort-headers.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Given a filename as an argument, sort the #include/#imports in that file.
 
 Shows a diff and prompts for confirmation before doing the deed.
 Works great with tools/git/for-all-touched-files.py.
 """
 
 import optparse
 import os
 import sys
 
 from yes_no import YesNo
 
 
-def IncludeCompareKey(line):
-  """Sorting comparator key used for comparing two #include lines.
-  Returns the filename without the #include/#import/import prefix.
-  """
-  for prefix in ('#include ', '#import ', 'import '):
-    if line.startswith(prefix):
-      line = line[len(prefix):]
-      break
-
-  # The win32 api has all sorts of implicit include order dependencies :-/
-  # Give a few headers special sort keys that make sure they appear before all
-  # other headers.
-  if line.startswith('<windows.h>'):  # Must be before e.g. shellapi.h
-    return '0'
-  if line.startswith('<atlbase.h>'):  # Must be before atlapp.h.
-    return '1' + line
-  if line.startswith('<ole2.h>'):  # Must be before e.g. intshcut.h
-    return '1' + line
-  if line.startswith('<unknwn.h>'):  # Must be before e.g. intshcut.h
-    return '1' + line
-
-  # C++ system headers should come after C system headers.
-  if line.startswith('<'):
-    if line.find('.h>') != -1:
-      return '2' + line.lower()
-    else:
-      return '3' + line.lower()
-
-  return '4' + line
-
-
 def IsInclude(line):
   """Returns True if the line is an #include/#import/import line."""
   return any([line.startswith('#include '), line.startswith('#import '),
               line.startswith('import ')])
 
 
-def SortHeader(infile, outfile):
+def SortHeader(infile, outfile, for_blink):
+  def IncludeCompareKey(line):

[Matt Giuca, 2015/07/07 05:20:53]

Hmm, not really a fan of nesting this whole function just to capture for_blink.

Move it back out. Add a for_blink argument to IncludeCompareKey. Then do (at the
top level inside this function):

compare_key = functools.partial(IncludeCompareKey, for_blink=for_blink)

(see: https://docs.python.org/2/library/functools.html#functools.partial)

Alternatively, if that's too much voodoo, do (as a nested function):

def CompareKey(line):
  return IncludeCompareKey(line, for_blink)

which is equivalent to functools.partial.

then

sorted(headerblock, key=compare_key)

[benwells, 2015/07/13 05:46:31]

Done the latter way as it seems more obvious.

+    """Sorting comparator key used for comparing two #include lines.
+    Returns the filename without the #include/#import/import prefix.
+    """
+    for prefix in ('#include ', '#import ', 'import '):
+      if line.startswith(prefix):
+        line = line[len(prefix):]
+        break
+
+    # The win32 api has all sorts of implicit include order dependencies :-/
+    # Give a few headers special sort keys that make sure they appear before all
+    # other headers.
+    if line.startswith('<windows.h>'):  # Must be before e.g. shellapi.h
+      return '0'
+    if line.startswith('<atlbase.h>'):  # Must be before atlapp.h.
+      return '1' + line
+    if line.startswith('<ole2.h>'):  # Must be before e.g. intshcut.h
+      return '1' + line
+    if line.startswith('<unknwn.h>'):  # Must be before e.g. intshcut.h
+      return '1' + line
+
+    if for_blink:
+      # Blink likes to have its "config.h" include first.
+      if line.startswith('"config.h"'):
+        return '0'

[Matt Giuca, 2015/07/07 05:20:53]

Won't this conflict with <windows.h>?

[benwells, 2015/07/13 05:46:31]

Yes. From looking at blink code they don't seem to worry about doing anything
special with windows.h, so I've just excluded all that special casing for blink.

+
+      # Blink sorts system headers after others. This is handled by sorting
+      # alphabetically so no need to do anything tricky.
+      return '1' + line
+
+    # C++ system headers should come after C system headers.
+    if line.startswith('<'):
+      if line.find('.h>') != -1:
+        return '2' + line.lower()
+      else:
+        return '3' + line.lower()
+
+    return '4' + line
+
   """Sorts the headers in infile, writing the sorted file to outfile."""
   for line in infile:
     if IsInclude(line):
       headerblock = []
       while IsInclude(line):
         infile_ended_on_include_line = False
         headerblock.append(line)
         # Ensure we don't die due to trying to read beyond the end of the file.
         try:
           line = infile.next()
         except StopIteration:
           infile_ended_on_include_line = True
           break
       for header in sorted(headerblock, key=IncludeCompareKey):
         outfile.write(header)
       if infile_ended_on_include_line:
         # We already wrote the last line above; exit to ensure it isn't written
         # again.
         return
       # Intentionally fall through, to write the line that caused
       # the above while loop to exit.
     outfile.write(line)
 
 
 def FixFileWithConfirmFunction(filename, confirm_function,
-                               perform_safety_checks):
+                               perform_safety_checks, for_blink = False):

[Matt Giuca, 2015/07/07 05:20:52]

No spaces around =.

"for_blink=False"

[benwells, 2015/07/13 05:46:31]

Done.

   """Creates a fixed version of the file, invokes |confirm_function|
   to decide whether to use the new file, and cleans up.
 
   |confirm_function| takes two parameters, the original filename and
   the fixed-up filename, and returns True to use the fixed-up file,
   false to not use it.
 
   If |perform_safety_checks| is True, then the function checks whether it is
   unsafe to reorder headers in this file and skips the reorder with a warning
   message in that case.
   """
   if perform_safety_checks and IsUnsafeToReorderHeaders(filename):
     print ('Not reordering headers in %s as the script thinks that the '
            'order of headers in this file is semantically significant.'
            % (filename))
     return
   fixfilename = filename + '.new'
   infile = open(filename, 'rb')
   outfile = open(fixfilename, 'wb')
-  SortHeader(infile, outfile)
+  SortHeader(infile, outfile, for_blink)
   infile.close()
   outfile.close()  # Important so the below diff gets the updated contents.
 
   try:
     if confirm_function(filename, fixfilename):
       if sys.platform == 'win32':
         os.unlink(filename)
       os.rename(fixfilename, filename)
   finally:
     try:
       os.remove(fixfilename)
     except OSError:
       # If the file isn't there, we don't care.
       pass
 
 
-def DiffAndConfirm(filename, should_confirm, perform_safety_checks):
+def DiffAndConfirm(filename, should_confirm, perform_safety_checks, for_blink):
   """Shows a diff of what the tool would change the file named
   filename to.  Shows a confirmation prompt if should_confirm is true.
   Saves the resulting file if should_confirm is false or the user
   answers Y to the confirmation prompt.
   """
   def ConfirmFunction(filename, fixfilename):
     diff = os.system('diff -u %s %s' % (filename, fixfilename))
     if sys.platform != 'win32':
       diff >>= 8
     if diff == 0:  # Check exit code.
       print '%s: no change' % filename
       return False
 
     return (not should_confirm or YesNo('Use new file (y/N)?'))
 
-  FixFileWithConfirmFunction(filename, ConfirmFunction, perform_safety_checks)
+  FixFileWithConfirmFunction(filename, ConfirmFunction, perform_safety_checks,
+                             for_blink)
 
 def IsUnsafeToReorderHeaders(filename):
   # *_message_generator.cc is almost certainly a file that generates IPC
   # definitions. Changes in include order in these files can result in them not
   # building correctly.
   if filename.find("message_generator.cc") != -1:
     return True
   return False
 
 def main():
   parser = optparse.OptionParser(usage='%prog filename1 filename2 ...')
   parser.add_option('-f', '--force', action='store_false', default=True,
                     dest='should_confirm',
                     help='Turn off confirmation prompt.')
   parser.add_option('--no_safety_checks',
                     action='store_false', default=True,
                     dest='perform_safety_checks',
                     help='Do not perform the safety checks via which this '
                     'script refuses to operate on files for which it thinks '
                     'the include ordering is semantically significant.')
+  parser.add_option('--for_blink', action='store_true', default=False,
+                    dest='for_blink', help='Whether the blink header sorting '
+                    'rules should be applied.')
   opts, filenames = parser.parse_args()
 
   if len(filenames) < 1:
     parser.print_help()
     return 1
 
   for filename in filenames:
-    DiffAndConfirm(filename, opts.should_confirm, opts.perform_safety_checks)
+    DiffAndConfirm(filename, opts.should_confirm, opts.perform_safety_checks,
+                   opts.for_blink)
 
 
 if __name__ == '__main__':
   sys.exit(main())