ThreadWatcher - On Android, don't generate the crash dump if

chrome/browser/metrics/thread_watcher.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.
 
 #include "chrome/browser/metrics/thread_watcher.h"
 
 #include <math.h>  // ceil
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 35 matching lines @@
 #endif
 
 void NullPointerCrash(int line_number) {
 #ifndef NDEBUG
   *NullPointer() = line_number;  // Crash.
 #else
   base::debug::DumpWithoutCrashing();
 #endif
 }
 
+#if !defined(OS_ANDROID)
+// TODO(rtenneti): Enabled crashing, after getting data.
+NOINLINE void StartupCrash() {
+  NullPointerCrash(__LINE__);
+}
+#endif  // OS_ANDROID
+
 NOINLINE void ShutdownCrash() {
   NullPointerCrash(__LINE__);
 }
 
 NOINLINE void ThreadUnresponsive_UI() {
   NullPointerCrash(__LINE__);
 }
 
 NOINLINE void ThreadUnresponsive_DB() {
   NullPointerCrash(__LINE__);
@@ skipping 809 matching lines @@
 
 // StartupWatchDogThread methods and members.
 //
 // Class for detecting hangs during startup.
 class StartupWatchDogThread : public base::Watchdog {
  public:
   // Constructor specifies how long the StartupWatchDogThread will wait before
   // alarming.
   explicit StartupWatchDogThread(const base::TimeDelta& duration)
       : base::Watchdog(duration, "Startup watchdog thread", true) {
+#if defined(OS_ANDROID)
+    // TODO(rtenneti): Delete this code, after getting data.
+    start_time_clock_= base::Time::Now();
+    start_time_monotonic_ = base::TimeTicks::Now();
+    start_time_thread_now_ = base::TimeTicks::IsThreadNowSupported()
+        ? base::TimeTicks::ThreadNow() : base::TimeTicks::Now();
+#endif  // OS_ANDROID
   }
 
   // Alarm is called if the time expires after an Arm() without someone calling
   // Disarm(). When Alarm goes off, in release mode we get the crash dump
   // without crashing and in debug mode we break into the debugger.
   virtual void Alarm() OVERRIDE {
+#if defined(OS_ANDROID)
+    // TODO(rtenneti): Delete this code, after getting data.
+    // On Android, we don't crash, but we will collect stats.
+    UMA_HISTOGRAM_TIMES("StartupTimebomm.Alarm.TimeDuration",
+                        base::Time::Now() - start_time_clock_);
+    UMA_HISTOGRAM_TIMES("StartupTimebomm.Alarm.TimeTicksDuration",
+                        base::TimeTicks::Now() - start_time_monotonic_);
+    if (base::TimeTicks::IsThreadNowSupported()) {
+      UMA_HISTOGRAM_TIMES(
+          "StartupTimebomm.Alarm.ThreadNowDuration",
+          base::TimeTicks::ThreadNow() - start_time_thread_now_);
+    }
+#else
 #ifndef NDEBUG

[jar (doing other things), 2014/05/03 02:00:21]

nit: I like less ifdef protected, and especially nested, blocks.  One small
change that might help is to change:

#else
#ifndef NDEBUG

into

#elif !defined(NDEBUG)


Maybe even nicer would be list the three block, each with a return, and to list
the smallest blocks first (for easy reading).  Something like

#if !defined(NDEBUG)
  DCHECK(false);
  return;
#elif !defined(OS_ANDROID)
  PostTask(to crash);
  return;
#else  // Android release: gather stats to figure out when to crash.
  UMA_HISTOGRAMS(...)
  return;
#endif

[ramant (doing other things), 2014/05/03 04:11:36]

Done.

-    DCHECK(false);
+    StartupCrash();
 #else
-    WatchDogThread::PostTask(FROM_HERE,
-                             base::Bind(&base::debug::DumpWithoutCrashing));

[jar (doing other things), 2014/05/03 02:00:21]

Is this a deliberate change to crashing?  Did you turn off crashing... and now
this will turn it back on for non-Android?

[ramant (doing other things), 2014/05/03 04:11:36]

In DEBUG builds we used to crash and we do the same.

For non DEBUG builds, instead of calling DumpWithoutCrashing directly, called
StartupCrash which calls DumpWithoutCrashing. This would show StartupCrash in
callstack (it would help in isolating if there are other watchdog based
crashes).

void NullPointerCrash(int line_number) {
#ifndef NDEBUG
  *NullPointer() = line_number;  // Crash.
#else
  base::debug::DumpWithoutCrashing();
#endif
}

NOINLINE void StartupCrash() {
  NullPointerCrash(__LINE__);
}

WDYT?

-#endif
+    WatchDogThread::PostTask(FROM_HERE, base::Bind(&StartupCrash));
+#endif  // NDEBUG
+#endif  // OS_ANDROID
   }
 
+ private:
+#if defined(OS_ANDROID)
+  // TODO(rtenneti): Delete this code, after getting data.
+  base::Time start_time_clock_;
+  base::TimeTicks start_time_monotonic_;
+  base::TimeTicks start_time_thread_now_;
+#endif  // OS_ANDROID
+
   DISALLOW_COPY_AND_ASSIGN(StartupWatchDogThread);
 };
 
 // ShutdownWatchDogThread methods and members.
 //
 // Class for detecting hangs during shutdown.
 class ShutdownWatchDogThread : public base::Watchdog {
  public:
   // Constructor specifies how long the ShutdownWatchDogThread will wait before
   // alarming.
   explicit ShutdownWatchDogThread(const base::TimeDelta& duration)
       : base::Watchdog(duration, "Shutdown watchdog thread", true) {
   }
 
   // Alarm is called if the time expires after an Arm() without someone calling
   // Disarm(). We crash the browser if this method is called.
   virtual void Alarm() OVERRIDE {
     ShutdownCrash();
   }
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(ShutdownWatchDogThread);
 };
 }  // namespace
 
 // StartupTimeBomb methods and members.
 //
 // static
 StartupTimeBomb* StartupTimeBomb::g_startup_timebomb_ = NULL;
 
 StartupTimeBomb::StartupTimeBomb()
@@ skipping 85 matching lines @@
 
 #if defined(OS_WIN)
   // On Windows XP, give twice the time for shutdown.
   if (base::win::GetVersion() <= base::win::VERSION_XP)
     actual_duration *= 2;
 #endif
 
   shutdown_watchdog_ = new ShutdownWatchDogThread(actual_duration);
   shutdown_watchdog_->Arm();
 }