Prevent code folding in the ThreadWatcher ThreadUnresponsive_X functions.

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 22 matching lines @@
 // We disable optimizations for this block of functions so the compiler doesn't
 // merge them all together.
 
 // TODO(eroman): What is the equivalent for other compilers?
 #if defined(COMPILER_MSVC)
 #pragma optimize("", off)
 MSVC_PUSH_DISABLE_WARNING(4748)
 #endif
 
 void ThreadUnresponsive_UI() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;

[eroman, 2012/07/03 19:00:38]

I am slightly surprised that CHECK(false) doesn't already generate unique
bodies. Since CHECK() macro will include the filename and line number, and the
line numbers should be different for each of the CHECK().

I suspect NOINLINE may be necessary here instead, but if this works then fine!

[Robert Sesek, 2012/07/10 18:43:09]

In official release builds, it looks like CHECK() gets turned into
base::debug::BreakDebugger, which won't generate the file/line data.

[jar (doing other things), 2012/07/10 20:05:23]

Reading the header file, it appears that they discard as much as possible to
avoid bloating the binary.  The approach you've taken here, reverses this trend,
and tries to force unique string names (function names) into the binary.   In
fact, it uses more memory than __FILE__ plus __LINE__ would, as the __FILE__
string would be shared in a const data segment, and only appear once.

Although the total memory used by your pattern in this case is not that great (a
couple of hundred bytes), the pattern seems worse than the segv approach I
mentioned.

Is there a reason why you prefer this that I'm missing?

 }
 
 void ThreadUnresponsive_DB() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_WEBKIT() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_FILE() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_FILE_USER_BLOCKING() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_PROCESS_LAUNCHER() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_CACHE() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 void ThreadUnresponsive_IO() {
-  CHECK(false);
+  CHECK(false) << __FUNCTION__;
 }
 
 #if defined(COMPILER_MSVC)
 MSVC_POP_WARNING()
 #pragma optimize("", on)
 #endif
 
 void CrashBecauseThreadWasUnresponsive(BrowserThread::ID thread_id) {
   base::debug::Alias(&thread_id);
 
@@ skipping 15 matching lines @@
     case BrowserThread::IO:
       return ThreadUnresponsive_IO();
     case BrowserThread::ID_COUNT:
       CHECK(false);  // This shouldn't actually be reached!
       break;
 
     // Omission of the default hander is intentional -- that way the compiler
     // should warn if our switch becomes outdated.
   }
 
-  CHECK(false);  // Shouldn't be reached.
+  CHECK(false) << "Unknown thread was unresponsive.";  // Shouldn't be reached.
 }
 
 }  // namespace
 
 // ThreadWatcher methods and members.
 ThreadWatcher::ThreadWatcher(const WatchingParams& params)
     : thread_id_(params.thread_id),
       thread_name_(params.thread_name),
       watched_loop_(
           BrowserThread::GetMessageLoopProxyForThread(params.thread_id)),
@@ skipping 802 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();
 }