Simulated Crash reporting for ErrAborted requests

content/browser/loader/resource_dispatcher_host_impl.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 
 #include <algorithm>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/alias.h"
+#include "base/debug/crash_logging.h"
+#include "base/debug/dump_without_crashing.h"
+#include "base/debug/stack_trace.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/stl_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/time/time.h"
@@ skipping 871 matching lines @@
     base::TimeDelta request_loading_time(
         base::TimeTicks::Now() - loader->request()->creation_time());
     switch (loader->request()->status().error()) {
       case net::OK:
         UMA_HISTOGRAM_LONG_TIMES(
             "Net.RequestTime2.Success", request_loading_time);
         break;
       case net::ERR_ABORTED:
         UMA_HISTOGRAM_LONG_TIMES(
             "Net.RequestTime2.ErrAborted", request_loading_time);
+        // 100ms is typically "instantaneous" in human perception.
+        if (request_loading_time.InMilliseconds() < 100) {
+          const char kFastErrAbortTrace[] = "fast-err-abort-trace";
+          const base::debug::StackTrace* stack_trace =
+              loader->request()->stack_trace();
+          if (stack_trace) {
+            base::debug::SetCrashKeyToStackTrace(kFastErrAbortTrace,

[eroman, 2015/11/16 22:56:11]

Instead of adding a crash key to the report, I think it will be easier to  just
alias a local variable:

base::Debug::StackTrace strack_trace_copy = *loader->request()->stack_trace();
base::Debug::Alias(&stack_trace_copy);
..
<dumpwithoutcrashing>


The advantage of this approach is you can easily symbolicate it for Windows
crash dumps using something like:
Also note that getting stack traces is somewhat unpredictable; it doesn't always
work. It is better now that we no longer omit the frame pointer, but I have done
this plenty of times and gotten back an unwalkable callstack, so don't hold your
breath :(

+                                                 *stack_trace);
+            base::debug::DumpWithoutCrashing();

[eroman, 2015/11/16 22:56:11]

Do you have any estimates on how often this will be called? Can you suggest some
limits or bounds on this?

As a safety-net, how about limiting this to either a total number per session
(say 1 or 2 for the lifetime of the browser), or maybe a time based threshold,
like 1 report at most every hour?

Also, put a link to the bug report by this line, so crash triagers will know
what it corresponds to.

+            base::debug::ClearCrashKey(kFastErrAbortTrace);
+          }
+        }
         break;
       case net::ERR_CONNECTION_RESET:
         UMA_HISTOGRAM_LONG_TIMES(
             "Net.RequestTime2.ErrConnectionReset", request_loading_time);
         break;
       case net::ERR_CONNECTION_TIMED_OUT:
         UMA_HISTOGRAM_LONG_TIMES(
             "Net.RequestTime2.ErrConnectionTimedOut", request_loading_time);
         break;
       case net::ERR_INTERNET_DISCONNECTED:
@@ skipping 1523 matching lines @@
     load_flags |= net::LOAD_PREFETCH;
   }
 
   if (is_sync_load)
     load_flags |= net::LOAD_IGNORE_LIMITS;
 
   return load_flags;
 }
 
 }  // namespace content