[Findit] Reorganizing findit_for_*.py

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 import classifier
+from crash.occurrence import RankByOccurrence
 from crash.type_enums import CallStackLanguageType
 from model.crash.crash_config import CrashConfig
 
-
-class ProjectClassifier(classifier.Classifier):
+class ProjectClassifier(object):
   """Determines the project of a crash - (project_name, project_path).
 
   For example: ('chromium', 'src/'), ('skia', 'src/skia/'), ...etc.
   """
 
   def __init__(self):
     super(ProjectClassifier, self).__init__()
     self.project_classifier_config = CrashConfig.Get().project_classifier
     if self.project_classifier_config:
       self.project_classifier_config['host_directories'].sort(
@@ skipping 32 matching lines @@
   def GetClassFromResult(self, result):
     """Returns (project_name, project_path) of a Result."""
     if result.file_to_stack_infos:
       # A file in culprit result should always have its stack_info, namely a
       # list of (frame, callstack_priority) pairs.
       frame, _ = result.file_to_stack_infos.values()[0][0]
       return self.GetClassFromStackFrame(frame)
 
     return ''
 
+  # TODO(wrengr): should return an object of some "Project" class;
+  # similar to how we handle components.
   def Classify(self, results, crash_stack):
     """Classify project of a crash.
 
     Args:
       results (list of Result): culprit results.
       crash_stack (CallStack): the callstack that caused the crash.
 
     Returns:
       A tuple, project of the crash - (project_name, project_path).
     """
     if not self.project_classifier_config:
-      logging.warning('Empty configuration for project classifier.')
-      return ''
+      logging.warning('ProjectClassifier.Classify: Empty configuration.')
+      return None
 
-    def _GetRankFunction(language_type):
-      if language_type == CallStackLanguageType.JAVA:
-        def _RankFunctionForJava(occurrence):
-          project_name = occurrence.name
-          return (len(occurrence),
-                  0 if 'chromium' in project_name else
-                  self.project_classifier_config[
-                      'non_chromium_project_rank_priority'][project_name])
+    rank_function = None
+    if crash_stack.language_type == CallStackLanguageType.JAVA:
+      def _RankFunctionForJava(occurrence):
+        project_name = occurrence.name
+        return (len(occurrence),
+                0 if 'chromium' in project_name else
+                self.project_classifier_config[
+                    'non_chromium_project_rank_priority'][project_name])
 
-        return _RankFunctionForJava
+      rank_function = _RankFunctionForJava
 
-      return classifier.DefaultRankFunction
+    top_n_frames = self.project_classifier_config['top_n']
+    # If |results| 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])
+    else:
+      classes = map(self.GetClassFromStackFrame, crash_stack[:top_n_frames])
 
-    # Set the max_classes to 1, so the returned projects only has one element.
-    projects = self._Classify(
-        results, crash_stack,
-        self.project_classifier_config['top_n'], 1,
-        rank_function=_GetRankFunction(crash_stack.language_type))
+    # 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:
+      if projects[0] is None:
+        logging.warning('ProjectClassifier.Classify: the highest ranking project is None.')
       return projects[0]
 
-    return ''
+    logging.warning('ProjectClassifier.Classify: no projects found.')
+    return None