[Predator] Move ``FilterStackBuffer`` from stack parser to ``AddFilteredStack`` of stacktrace buffe…

appengine/findit/crash/stacktrace.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.
 
 from collections import namedtuple
 import copy
 import logging
+import math
 import re
 
 from crash import parse_util
 from crash.type_enums import CallStackFormatType
 from crash.type_enums import LanguageType
 
 # Used to parse a line into StackFrame of a Callstack.
 CALLSTACK_FORMAT_TO_PATTERN = {
     CallStackFormatType.JAVA: re.compile(
         r'at ([A-Za-z0-9$._<>]+)\(\w+(\.java)?:(\d+)\)'),
@@ skipping 284 matching lines @@
   __bool__ = __nonzero__
 
   def __iter__(self):
     """Iterator over the stacks in this trace."""
     return iter(self.stacks)
 
 
 class StacktraceBuffer(object):
   """A Mutable type to simplify constructing ``Stacktrace`` objects.
 
   The class can be converted to immutable stacktrace.

[wrengr, 2016/12/22 22:42:59]

this paragraph should be formatted to avoid weird line breaks. From vim, can use
!}fmt or similar

[Sharu Jiang, 2016/12/23 00:26:20]

Done.

   using ``ToStacktrace``.
   Note, to make this class fully mutable, it should contain CallStackBuffer
   list instead of CallStack list.
   """
-  def __init__(self, stacks=None, signature=None):
+  def __init__(self, stacks=None, signature=None, filters=None):
     """Initialize StacktraceBuffer instance.
 
     Args:
       stacks (list of CallStackBuffer): CallStackBuffer objects to
         build stacktrace.
-      signature (str): signagure is used to determine the crash stack.
+      signature (str): The signagure is used to determine the crash stack.

[wrengr, 2016/12/22 22:42:59]

"signagure" -> "signature"

[Sharu Jiang, 2016/12/23 00:26:20]

Done.

+      filters (list of CallStackBuffer): List of filters to filter stack buffer.

[wrengr, 2016/12/22 22:43:00]

Those aren't CallStackBuffers...

"filters to filter" is awkward

[Sharu Jiang, 2016/12/23 00:26:19]

Oops, corrected.

     """
     self.stacks = stacks or []
     if signature:
       # Filter out the types of signature, for example [Out of Memory].
       signature = re.sub('[[][^]]*[]]\s*', '', signature)
       # For clusterfuzz crash, the signature is crash state. It is
       # usually the top 3 important stack frames separated by '\n'.
       self.signature_parts = signature.splitlines()
     else:
       self.signature_parts = None
+    self.filters = filters

[wrengr, 2016/12/22 22:42:59]

should have a blank line before this, iirc

[Sharu Jiang, 2016/12/23 00:26:20]

Done.

 
   def __nonzero__(self):
     """Returns whether this trace buffer is empty."""
     return bool(self.stacks)
   __bool__ = __nonzero__
 
+  def AddFilteredStack(self, stack_buffer):
+    """Filters stack_buffer and add it to stacks if it's not empty."""
+    # If the callstack is the initial one (infinte priority) or empty, return
+    # None.
+    if math.isinf(stack_buffer.priority) or not stack_buffer.frames:
+      return
+
+    if self.filters:
+      for stack_filter in self.filters:

[wrengr, 2016/12/22 22:42:59]

``if filters: for f in filters:...`` -> ``for f in filters or []:...``

[Sharu Jiang, 2016/12/23 00:26:19]

Done.

+        stack_buffer = stack_filter(stack_buffer)
+        if not stack_buffer:
+          return
+
+    self.stacks.append(stack_buffer)
+
   def ToStacktrace(self):
     """Converts to ``Stacktrace`` object."""
     if not self:
       return None
 
     # Get the callstack with the highest priority (i.e., whose priority
     # field is numerically the smallest) in the stacktrace.
     crash_stack_index = None
     if self.signature_parts:
       def _IsSignatureCallstack(callstack):
@@ skipping 19 matching lines @@
                   for stack_buffer in self.stacks]
 
     if crash_stack_index is None:
       # If there is no signature callstack, fall back to set crash stack using
       # the first least priority callstack.
       crash_stack = min(callstacks, key=lambda stack: stack.priority)
     else:
       crash_stack = callstacks[crash_stack_index]
 
     return Stacktrace(tuple(callstacks), crash_stack)