[Findit] Fix blame for GIT and uptake bug fix.

tools/findit/findit_for_crash.py

 # Copyright (c) 2014 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.
 
 import os
-from threading import Lock, Thread
+from threading import Lock
 
 import blame
 from common import utils
 import component_dictionary
 import crash_utils
 import git_repository_parser
 import match_set
 import svn_repository_parser
 
 
@@ skipping 115 matching lines @@
                        stacktrace.
     component_path: The path of the component to search for.
     component_name: The name of the component to search for.
     repository_parser: The parser object to parse the line diff.
     codereview_api_url: A code review url to retrieve data from.
 
   Returns:
     Matches, a set of match objects.
   """
   matches = match_set.MatchSet(codereview_api_url)
-  threads = []
 
+  tasks = []
   # Iterate through the crashed files in the stacktrace.
   for crashed_file_path in file_to_crash_info:
     # Ignore header file.
     if crashed_file_path.endswith('.h'):
       continue
 
     # If the file in the stacktrace is not changed in any commits, continue.
     for changed_file_path in file_to_revision_info:
       changed_file_name = changed_file_path.split('/')[-1].lower()
       crashed_file_name = crashed_file_path.split('/')[-1].lower()
@@ skipping 11 matching lines @@
       functions = file_to_crash_info.GetCrashFunctions(crashed_file_path)
 
       # Iterate through the CLs that this file path is changed.
       for (cl, file_change_type) in file_to_revision_info[changed_file_path]:
         # If the file change is delete, ignore this CL.
         if file_change_type == 'D':
           continue
 
         revision = revisions_info_map[cl]
 
-        match_thread = Thread(
-            target=GenerateMatchEntry,
-            args=[matches, revision, cl, changed_file_path, functions,
+        tasks.append({
+            'function': GenerateMatchEntry,
+            'args': [matches, revision, cl, changed_file_path, functions,
                   component_path, component_name, crashed_line_numbers,
                   stack_frame_nums, file_change_type,
-                  repository_parser])
-        threads.append(match_thread)
-        match_thread.start()
+                  repository_parser]
+        })
 
-  for match_thread in threads:
-    match_thread.join()
+  # Run all the tasks.
+  crash_utils.RunTasks(tasks)
 
   matches.RemoveRevertedCLs()
 
   return matches
 
 
 def FindMatchForComponent(component_path, file_to_crash_info, changelog,
                           callstack_priority, results, results_lock):
   """Parses changelog and finds suspected CLs for a given component.
 
@@ skipping 38 matching lines @@
     components: A set of components to look for.
     component_to_changelog_map: A map from component to its parsed changelog.
     results: A list to aggregrate results from all stacktraces.
     results_lock: A lock that guards results.
   """
   # Create component dictionary from the component and call stack.
   component_dict = component_dictionary.ComponentDictionary(callstack,
                                                             components)
   callstack_priority = callstack.priority
 
+  tasks = []
   # Iterate through all components and create new thread for each component.
-  threads = []
   for component_path in component_dict:
     # If the component to consider in this callstack is not in the parsed list
     # of components, ignore this one.
     if component_path not in component_to_changelog_map:
       continue
 
     changelog = component_to_changelog_map[component_path]
     file_to_crash_info = component_dict.GetFileDict(component_path)
-    t = Thread(
-        target=FindMatchForComponent,
-        args=[component_path, file_to_crash_info, changelog,
-              callstack_priority, results, results_lock])
-    threads.append(t)
-    t.start()
+    tasks.append({
+        'function': FindMatchForComponent,
+        'args': [component_path, file_to_crash_info, changelog,
+                 callstack_priority, results, results_lock]
+    })
 
-  for t in threads:
-    t.join()
+  # Run all the tasks.
+  crash_utils.RunTasks(tasks)
 
 
 def FindMatchForStacktrace(stacktrace, components,
                            component_to_regression_dict):
   """Finds the culprit CL for stacktrace.
 
   The passed stacktrace is either from release build stacktrace
   or debug build stacktrace.
 
   Args:
@@ skipping 40 matching lines @@
     # If the returned map from ParseChangeLog is empty, we don't need to look
     # further because either the parsing failed or the changelog is empty.
     if not (revisions and file_to_revision_map):
       continue
 
     component_to_changelog_map[component_path] = (repository_parser,
                                                   component_name,
                                                   revisions,
                                                   file_to_revision_map)
 
+  tasks = []
   # Create separate threads for each of the call stack in the stacktrace.
-  threads = []
   for callstack in stacktrace.stack_list:
-    t = Thread(
-        target=FindMatchForCallstack,
-        args=[callstack, components, component_to_changelog_map,
-              results, results_lock])
-    threads.append(t)
-    t.start()
+    tasks.append({
+        'function': FindMatchForCallstack,
+        'args': [callstack, components, component_to_changelog_map,
+                 results, results_lock]
+    })
 
-  for t in threads:
-    t.join()
+  # Run all the tasks.
+  crash_utils.RunTasks(tasks)
 
   return results
 
 
 def SortMatchesFunction(match_with_stack_priority):
   """A function to sort the match triple.
 
   Currently, it sorts the list by:
   1) The highest priority file change in the CL (changing crashed line is
   higher priority than just changing the file).
@@ skipping 125 matching lines @@
           file_string = 'File %s is changed in this cl '
         else:
           file_string = 'Files %s are changed in this cl '
 
         # Create a list of file names, and prettify the list.
         file_names = [
             file_name for (_, _, file_name, _, _) in rest_of_the_files]
         pretty_file_names = crash_utils.PrettifyList(file_names)
 
         # Add the reason, break because we took care of the rest of the files.
-        file_string += '(%s)' % crash_utils.PrettifyFrameInfo(
-            stack_frame_indices, function_list)
+        file_string += ('(and is part of stack %s)' %
+            crash_utils.PrettifyFrameInfo(stack_frame_indices, function_list))
         reason.append(file_string % pretty_file_names)
         break
 
     # Set the reason as string.
     match.reason = '\n'.join(reason)
 
 
 def CombineMatches(matches):
   """Combine possible duplicates in matches.
 
@@ skipping 23 matching lines @@
     # Combine the reason if the current match is already in there.
     found_match.reason += match.reason
     if match.min_distance < found_match.min_distance:
       found_match.min_distance = match.min_distance
       found_match.min_distance_info = match.min_distance_info
 
   for stack_index, cl, match in combined_matches:
     if match.min_distance_info:
       file_name, min_crashed_line, min_changed_line = match.min_distance_info
       match.reason += \
-          ('Minimum distance from crashed line to changed line: %d. '
-           '(File: %s, Crashed on: %d, Changed: %d).\n' %
+          ('\nMinimum distance from crash line to modified line: %d. '
+           '(file: %s, crashed on: %d, modified: %d).\n' %
            (match.min_distance, file_name, min_crashed_line, min_changed_line))
 
   return combined_matches
 
 
 def FilterAndGenerateReasonForMatches(result):
   """A wrapper function.
 
   It generates reasons for the matches and returns string representation
   of filtered results.
@@ skipping 124 matching lines @@
     return (return_message, filtered_result)
 
   # If no match is found, return the blame information for the input
   # callstack.
   result = GenerateAndFilterBlameList(
       callstack, component_to_crash_revision_dict,
       component_to_regression_dict)
 
   if result:
     return_message = (
-        'No CL in the regression changes the crashed files. The result is '
-        'the blame information.')
+        'No CL in the regression range changes the crashed files. '
+        'The result is the blame information.')
 
   # When findit could not find any CL that changes file in stacktrace or if
   # if cannot get any blame information, return a message saying that no
   # results are available.
   else:
     return_message = ('Findit could not find any suspected CLs.')
 
   return (return_message, result)