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

tools/findit/blame.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.
 
-from threading import Lock, Thread
+from threading import Lock
 
 from common import utils
 import crash_utils
 
 
 class Blame(object):
   """Represents a blame object.
 
   The object contains blame information for one line of stack, and this
   information is shown when there are no CLs that change the crashing files.
@@ skipping 54 matching lines @@
       callstack: The list of stack frames.
       component_to_crash_revision_dict: A dictionary that maps component to its
                                         crash revision.
       component_to_regression_dict: A dictionary that maps component to its
                                     revision range.
       parsers: A list of two parsers, svn_parser and git_parser
       top_n_frames: A number of stack frames to show the blame result for.
     """
     # Only return blame information for first 'top_n_frames' frames.
     stack_frames = callstack.GetTopNFrames(top_n_frames)
-    threads = []
+    tasks = []
     # Iterate through frames in stack.
     for stack_frame in stack_frames:
       # If the component this line is from does not have a crash revision,
       # it is not possible to get blame information, so ignore this line.
       component_path = stack_frame.component_path
       if component_path not in component_to_crash_revision_dict:
         continue
 
       crash_revision = component_to_crash_revision_dict[
           component_path]['revision']
       range_start = None
       range_end = None
       repository_type = crash_utils.GetRepositoryType(crash_revision)
       repository_parser = parsers[repository_type]
 
       # If the revision is in SVN, and if regression information is available,
       # get it. For Git, we cannot know the ordering between hash numbers.
       if repository_type == 'svn':
         if component_to_regression_dict and \
             component_path in component_to_regression_dict:
           component_object = component_to_regression_dict[component_path]
           range_start = int(component_object['old_revision'])
           range_end = int(component_object['new_revision'])
 
-      # Generate blame entry, one thread for one entry.
-      blame_thread = Thread(
-          target=self.__GenerateBlameEntry,
-          args=[repository_parser, stack_frame, crash_revision,
-                range_start, range_end])
-      threads.append(blame_thread)
-      blame_thread.start()
+      # Create a task to generate blame entry.
+      tasks.append({
+          'function': self.__GenerateBlameEntry,
+          'args': [repository_parser, stack_frame, crash_revision,
+                   range_start, range_end]
+      })
 
-    # Join the results before returning.
-    for blame_thread in threads:
-      blame_thread.join()
+    # Run all the tasks.
+    crash_utils.RunTasks(tasks)
+
 
   def __GenerateBlameEntry(self, repository_parser, stack_frame,
                            crash_revision, range_start, range_end):
     """Generates blame list from the arguments."""
     stack_frame_index = stack_frame.index
     component_path = stack_frame.component_path
     component_name = stack_frame.component_name
     file_name = stack_frame.file_name
     file_path = stack_frame.file_path
     crashed_line_number = stack_frame.crashed_line_range[0]
 
+    if file_path.startswith(component_path):
+      file_path = file_path[len(component_path):]
+
     # Parse blame information.
     parsed_blame_info = repository_parser.ParseBlameInfo(
         component_path, file_path, crashed_line_number, crash_revision)
 
     # If it fails to retrieve information, do not do anything.
     if not parsed_blame_info:
       return
 
     # Create blame object from the parsed info and add it to the list.
     (line_content, revision, author, url, message) = parsed_blame_info
@@ skipping 17 matching lines @@
       if blame.range_start and blame.range_end:
 
         # Discards results that are after the end of regression.
         if not utils.IsGitHash(blame.revision) and (
             int(blame.range_end) <= int(blame.revision)):
           continue
 
       filtered_blame_list.append(blame)
 
     self.blame_list = filtered_blame_list