[Predator] renamed "Result" to "Suspect"

appengine/findit/crash/project_classifier.py

 # Copyright 2016 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 logging
 
 from crash.occurrence import RankByOccurrence
 from crash.type_enums import CallStackLanguageType
 from model.crash.crash_config import CrashConfig
 
@@ skipping 36 matching lines @@
       if frame.function.startswith(marker):
         return name
 
     for marker, name in self.project_classifier_config[
         'file_path_marker_to_project_name'].iteritems():
       if marker in frame.file_path or marker in frame.raw_file_path:
         return name
 
     return self._GetProjectFromDepPath(frame.dep_path)
 
-  # TODO(wrengr): refactor this into a method on Result which returns
+  # TODO(wrengr): refactor this into a method on Suspect which returns
   # the cannonical frame (and documents why it's the one we return).
-  def GetClassFromResult(self, result):
-    """Determine which project is responsible for this result."""
-    if result.file_to_stack_infos:
+  def GetClassFromSuspect(self, suspect):
+    """Determine which project is responsible for this suspect."""
+    if suspect.file_to_stack_infos:
       # file_to_stack_infos is a dict mapping file_path to stack_infos,
       # where stack_infos is a list of (frame, callstack_priority)
       # pairs. So ``.values()`` returns a list of the stack_infos in an
       # arbitrary order; the first ``[0]`` grabs the "first" stack_infos;
       # the second ``[0]`` grabs the first pair from the list; and
       # the third ``[0]`` grabs the ``frame`` from the pair.
       # TODO(wrengr): why is that the right frame to look at?
-      frame = result.file_to_stack_infos.values()[0][0][0]
+      frame = suspect.file_to_stack_infos.values()[0][0][0]
       return self.GetClassFromStackFrame(frame)
 
     return ''
 
-  def Classify(self, results, crash_stack):
+  def Classify(self, suspects, crash_stack):
     """Classify project of a crash.
 
     Args:
-      results (list of Result): culprit results.
+      suspects (list of Suspect): culprit suspects.
       crash_stack (CallStack): the callstack that caused the crash.
 
     Returns:
       The name of the most-suspected project; or the empty string on failure.
     """
     if not self.project_classifier_config:
       logging.warning('ProjectClassifier.Classify: Empty configuration.')
       return None
 
     rank_function = None
     if crash_stack.language_type == CallStackLanguageType.JAVA:
       def _RankFunctionForJava(occurrence):
         # TODO(wrengr): why are we weighting by the length, instead of
         # the negative length as we do in the DefaultOccurrenceRanging?
         weight = len(occurrence)
         project_name = occurrence.name
         if 'chromium' in project_name:
           index = 0
         else:
           index = self.project_classifier_config[
               'non_chromium_project_rank_priority'][project_name]
         return (weight, index)
 
       rank_function = _RankFunctionForJava
 
     top_n_frames = self.project_classifier_config['top_n']
-    # If ``results`` are available, we use the projects from there since
+    # If ``suspects`` are available, we use the projects from there since
     # they're more reliable than the ones from the ``crash_stack``.
-    if results:
-      classes = map(self.GetClassFromResult, results[:top_n_frames])
+    if suspects:
+      classes = map(self.GetClassFromSuspect, suspects[:top_n_frames])
     else:
       classes = map(self.GetClassFromStackFrame,
           crash_stack.frames[:top_n_frames])
 
     # Since we're only going to return the highest-ranked class, might
     # as well set ``max_classes`` to 1.
     projects = RankByOccurrence(classes, 1, rank_function=rank_function)
 
     if projects:
       return projects[0]
 
     logging.warning('ProjectClassifier.Classify: no projects found.')
     return ''