Add a new 'format-webkitpy' command that will reformat code to the style guide.

Tools/Scripts/webkitpy/common/system/executive.py

 # Copyright (c) 2009, Google Inc. All rights reserved.
 # Copyright (c) 2009 Apple Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 453 matching lines @@
         else:
             string_args = self._stringify_args(args)
         return subprocess.Popen(string_args, **kwargs)
 
     def call(self, args, **kwargs):
         return subprocess.call(self._stringify_args(args), **kwargs)
 
     def run_in_parallel(self, command_lines_and_cwds, processes=None):
         """Runs a list of (cmd_line list, cwd string) tuples in parallel and returns a list of (retcode, stdout, stderr) tuples."""
         assert len(command_lines_and_cwds)
+        return self.map(_run_command_thunk, command_lines_and_cwds, processes)
 
-        if sys.platform in ('cygwin', 'win32'):
-            return map(_run_command_thunk, command_lines_and_cwds)
-        pool = multiprocessing.Pool(processes=processes)
-        results = pool.map(_run_command_thunk, command_lines_and_cwds)
-        pool.close()
-        pool.join()
-        return results
+    def map(self, thunk, arglist, processes=None):
+        if sys.platform in ('cygwin', 'win32') or len(arglist) == 1:
+            return map(thunk, arglist)
+        pool = multiprocessing.Pool(processes=(processes or multiprocessing.cpu_count()))
+        try:
+            return pool.map(thunk, arglist)

[eseidel, 2014/09/09 23:10:55]

This may be incompatible with keyboard interrupts:
http://bugs.python.org/issue8296

[Dirk Pranke, 2014/09/09 23:32:22]

Could be. I can switch this to a fancier pool if need be.

+        finally:
+            pool.close()
+            pool.join()
 
 
 def _run_command_thunk(cmd_line_and_cwd):
     # Note that this needs to be a bare module (and hence Picklable) method to work with multiprocessing.Pool.
     (cmd_line, cwd) = cmd_line_and_cwd
     proc = subprocess.Popen(cmd_line, cwd=cwd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     stdout, stderr = proc.communicate()
     return (proc.returncode, stdout, stderr)