crash-reporter: keep ignoring chrome crashes even on dev builds

user_collector.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "crash-reporter/user_collector.h"
 
 #include <grp.h>  // For struct group.
 #include <pcrecpp.h>
 #include <pcrecpp.h>
 #include <pwd.h>  // For struct passwd.
@@ skipping 397 matching lines @@
   return true;
 }
 
 bool UserCollector::ParseCrashAttributes(const std::string &crash_attributes,
                                          pid_t *pid, int *signal,
                                          std::string *kernel_supplied_name) {
   pcrecpp::RE re("(\\d+):(\\d+):(.*)");
   return re.FullMatch(crash_attributes, pid, signal, kernel_supplied_name);
 }
 
+bool UserCollector::ShouldDump(bool has_owner_consent,
+                               bool is_developer,
+                               bool is_crash_test_in_progress,
+                               const std::string &exec,
+                               std::string *reason) {
+  reason->clear();
+
+  // Treat Chrome crashes as if the user opted-out.  We stop counting Chrome
+  // crashes towards user crashes, so user crashes really mean non-Chrome
+  // user-space crashes.
+  if (exec == "chrome" || exec == "supplied_chrome") {
+    *reason = "ignoring - chrome crash";
+    return false;
+  }
+
+  // For developer builds, we always want to keep the crash reports unless
+  // we're testing the crash facilities themselves.  This overrides
+  // feedback.  Crash sending still obeys consent.
+  if (is_developer && !is_crash_test_in_progress) {
+    *reason = "developer build - not testing - always dumping";
+    return true;
+  }
+
+  if (!has_owner_consent) {
+    *reason = "ignoring - no consent";
+    return false;
+  }
+
+  *reason = "handling";
+  return true;
+}
+
 bool UserCollector::HandleCrash(const std::string &crash_attributes,
                                 const char *force_exec) {
   CHECK(initialized_);
   int pid = 0;
   int signal = 0;
   std::string kernel_supplied_name;
 
   if (!ParseCrashAttributes(crash_attributes, &pid, &signal,
                             &kernel_supplied_name)) {
     LOG(ERROR) << "Invalid parameter: --user=" <<  crash_attributes;
@@ skipping 15 matching lines @@
   if (!FLAGS_filter_in.empty() &&
       (FLAGS_filter_in == "none" ||
        FLAGS_filter_in != exec)) {
     // We use a different format message to make it more obvious in tests
     // which crashes are test generated and which are real.
     LOG(WARNING) << "Ignoring crash from " << exec << "[" << pid << "] while "
                  << "filter_in=" << FLAGS_filter_in << ".";
     return true;
   }
 
-  bool feedback = is_feedback_allowed_function_();
-  const char *handling_string = "handling";
-  if (!feedback) {
-    handling_string = "ignoring - no consent";
-  }
-
-  // Treat Chrome crashes as if the user opted-out.  We stop counting Chrome
-  // crashes towards user crashes, so user crashes really mean non-Chrome
-  // user-space crashes.
-  if (exec == "chrome" || exec == "supplied_chrome") {
-    feedback = false;
-    handling_string = "ignoring - chrome crash";
-  }
+  std::string reason;
+  bool dump = ShouldDump(is_feedback_allowed_function_(),
+                         file_util::PathExists(FilePath(kLeaveCoreFile)),
+                         IsCrashTestInProgress(),
+                         exec,
+                         &reason);
 
   LOG(WARNING) << "Received crash notification for " << exec << "[" << pid
-               << "] sig " << signal << " (" << handling_string << ")";
+               << "] sig " << signal << " (" << reason << ")";
 
-  // For developer builds, we always want to keep the crash reports unless
-  // we're testing the crash facilities themselves.
-  if (file_util::PathExists(FilePath(kLeaveCoreFile)) &&
-      !IsCrashTestInProgress()) {
-    feedback = true;
-  }
-
-  if (feedback) {
+  if (dump) {
     count_crash_function_();
 
     if (generate_diagnostics_) {
       bool out_of_capacity = false;
       bool convert_and_enqueue_result =
           ConvertAndEnqueueCrash(pid, exec, &out_of_capacity);
       if (!convert_and_enqueue_result) {
         if (!out_of_capacity)
           EnqueueCollectionErrorLog(pid, exec);
         return false;
       }
     }
   }
 
   return true;
 }