Update from https://crrev.com/305340

tools/clang/scripts/run_tool.py

 #!/usr/bin/env python
 # Copyright (c) 2013 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.
 
 """Wrapper script to help run clang tools across Chromium code.
 
 How to use this tool:
 If you want to run the tool across all Chromium code:
 run_tool.py <tool> <path/to/compiledb>
 
+If you want to include all files mentioned in the compilation database:
+run_tool.py <tool> <path/to/compiledb> --all
+
 If you only want to run the tool across just chrome/browser and content/browser:
 run_tool.py <tool> <path/to/compiledb> chrome/browser content/browser
 
 Please see https://code.google.com/p/chromium/wiki/ClangToolRefactoring for more
 information, which documents the entire automated refactoring flow in Chromium.
 
 Why use this tool:
 The clang tool implementation doesn't take advantage of multiple cores, and if
 it fails mysteriously in the middle, all the generated replacements will be
 lost.
 
 Unfortunately, if the work is simply sharded across multiple cores by running
 multiple RefactoringTools, problems arise when they attempt to rewrite a file at
 the same time. To work around that, clang tools that are run using this tool
 should output edits to stdout in the following format:
 
 ==== BEGIN EDITS ====
 r:<file path>:<offset>:<length>:<replacement text>
 r:<file path>:<offset>:<length>:<replacement text>
 ...etc...
 ==== END EDITS ====
 
 Any generated edits are applied once the clang tool has finished running
 across Chromium, regardless of whether some instances failed or not.
 """
 
 import collections
 import functools
+import json
 import multiprocessing
 import os.path
 import pipes
 import subprocess
 import sys
 
 
 Edit = collections.namedtuple(
     'Edit', ('edit_type', 'offset', 'length', 'replacement'))
 
@@ skipping 10 matching lines @@
   else:
     args.append('git')
   args.append('ls-files')
   if paths:
     args.extend(paths)
   command = subprocess.Popen(args, stdout=subprocess.PIPE)
   output, _ = command.communicate()
   return [os.path.realpath(p) for p in output.splitlines()]
 
 
+def _GetFilesFromCompileDB(build_directory):
+  """ Gets the list of files mentioned in the compilation database.
+
+  Args:
+    build_directory: Directory that contains the compile database.
+  """
+  compiledb_path = os.path.join(build_directory, 'compile_commands.json')
+  with open(compiledb_path, 'rb') as compiledb_file:
+    json_commands = json.load(compiledb_file)
+
+  return [os.path.join(entry['directory'], entry['file'])
+          for entry in json_commands]
+
+
 def _ExtractEditsFromStdout(build_directory, stdout):
   """Extracts generated list of edits from the tool's stdout.
 
   The expected format is documented at the top of this file.
 
   Args:
     build_directory: Directory that contains the compile database. Used to
       normalize the filenames.
     stdout: The stdout from running the clang tool.
 
@@ skipping 208 matching lines @@
   clang_format_diff_path = os.path.join(
       os.path.dirname(os.path.realpath(__file__)),
       '../../../third_party/llvm/tools/clang/tools/clang-format',
       'clang-format-diff.py')
   # TODO(dcheng): Allow this to be controlled with a flag as well.
   # TODO(dcheng): Shell escaping of args to git diff to clang-format is broken
   # on Windows.
   if not os.path.isfile(clang_format_diff_path) or sys.platform == 'win32':
     clang_format_diff_path = None
 
-  filenames = frozenset(_GetFilesFromGit(argv[2:]))
+  if len(argv) == 3 and argv[2] == '--all':
+    filenames = frozenset(_GetFilesFromCompileDB(argv[1]))
+  else:
+    filenames = frozenset(_GetFilesFromGit(argv[2:]))
   # Filter out files that aren't C/C++/Obj-C/Obj-C++.
   extensions = frozenset(('.c', '.cc', '.m', '.mm'))
   dispatcher = _CompilerDispatcher(argv[0], argv[1],
                                    [f for f in filenames
                                     if os.path.splitext(f)[1] in extensions])
   dispatcher.Run()
   # Filter out edits to files that aren't in the git repository, since it's not
   # useful to modify files that aren't under source control--typically, these
   # are generated files or files in a git submodule that's not part of Chromium.
   _ApplyEdits({k : v for k, v in dispatcher.edits.iteritems()
                     if os.path.realpath(k) in filenames},
               clang_format_diff_path)
   if dispatcher.failed_count != 0:
     return 2
   return 0
 
 
 if __name__ == '__main__':
   sys.exit(main(sys.argv[1:]))