Update the tcmalloc chromium branch to r144 (gperftools 2.0), and merge chromium-specific changes.

third_party/tcmalloc/chromium/src/tests/profile-handler_unittest.cc

 // Copyright 2009 Google Inc. All Rights Reserved.
 // Author: Nabeel Mian (nabeelmian@google.com)
 //         Chris Demetriou (cgd@google.com)
 //
 // This file contains the unit tests for profile-handler.h interface.
+//
+// It is linked into three separate unit tests:
+//     profile-handler_unittest tests basic functionality
+//     profile-handler_disable_test tests that the profiler
+//         is disabled with --install_signal_handlers=false
+//     profile-handler_conflict_test tests that the profiler
+//         is disabled when a SIGPROF handler is registered before InitGoogle.
 
 #include "config.h"
 #include "profile-handler.h"
 
 #include <assert.h>
 #include <pthread.h>
 #include <sys/time.h>
 #include <time.h>
 #include "base/logging.h"
 #include "base/simple_mutex.h"
 
 // Some helpful macros for the test class
 #define TEST_F(cls, fn)    void cls :: fn()
 
+// Do we expect the profiler to be enabled?
+DEFINE_bool(test_profiler_enabled, true,
+            "expect profiler to be enabled during tests");
+
+// Should we look at the kernel signal handler settings during the test?
+// Not if we're in conflict_test, because we can't distinguish its nop
+// handler from the real one.
+DEFINE_bool(test_profiler_signal_handler, true,
+            "check profiler signal handler during tests");
+
 namespace {
 
 // TODO(csilvers): error-checking on the pthreads routines
 class Thread {
  public:
   Thread() : joinable_(false) { }
   void SetJoinable(bool value) { joinable_ = value; }
   void Start() {
     pthread_attr_t attr;
     pthread_attr_init(&attr);
@@ skipping 241 matching lines @@
     ProfileHandlerGetState(&state);
     return state.interrupts;
   }
 
   // Verifies that a callback is correctly registered and receiving
   // profile ticks.
   void VerifyRegistration(const int& tick_counter) {
     // Check the callback count.
     EXPECT_GT(GetCallbackCount(), 0);
     // Check that the profile timer is enabled.
-    EXPECT_TRUE(IsTimerEnabled());
+    EXPECT_EQ(FLAGS_test_profiler_enabled, IsTimerEnabled());
     // Check that the signal handler is enabled.
-    EXPECT_TRUE(IsSignalEnabled());
+    if (FLAGS_test_profiler_signal_handler) {
+      EXPECT_EQ(FLAGS_test_profiler_enabled, IsSignalEnabled());
+    }
     uint64 interrupts_before = GetInterruptCount();
     // Sleep for a bit and check that tick counter is making progress.
     int old_tick_count = tick_counter;
     Delay(kSleepInterval);
     int new_tick_count = tick_counter;
-    EXPECT_GT(new_tick_count, old_tick_count);
     uint64 interrupts_after = GetInterruptCount();
-    EXPECT_GT(interrupts_after, interrupts_before);
+    if (FLAGS_test_profiler_enabled) {
+      EXPECT_GT(new_tick_count, old_tick_count);
+      EXPECT_GT(interrupts_after, interrupts_before);
+    } else {
+      EXPECT_EQ(new_tick_count, old_tick_count);
+      EXPECT_EQ(interrupts_after, interrupts_before);
+    }
   }
 
   // Verifies that a callback is not receiving profile ticks.
   void VerifyUnregistration(const int& tick_counter) {
     // Sleep for a bit and check that tick counter is not making progress.
     int old_tick_count = tick_counter;
     Delay(kSleepInterval);
     int new_tick_count = tick_counter;
     EXPECT_EQ(old_tick_count, new_tick_count);
     // If no callbacks, signal handler and shared timer should be disabled.
     if (GetCallbackCount() == 0) {
-      EXPECT_FALSE(IsSignalEnabled());
+      if (FLAGS_test_profiler_signal_handler) {
+        EXPECT_FALSE(IsSignalEnabled());
+      }
       if (timer_separate_) {
         EXPECT_TRUE(IsTimerEnabled());
       } else {
         EXPECT_FALSE(IsTimerEnabled());
       }
     }
   }
 
   // Verifies that the SIGPROF/SIGALRM interrupt handler is disabled and the
   // timer, if shared, is disabled. Expects the worker to be running.
   void VerifyDisabled() {
     // Check that the signal handler is disabled.
-    EXPECT_FALSE(IsSignalEnabled());
+    if (FLAGS_test_profiler_signal_handler) {
+      EXPECT_FALSE(IsSignalEnabled());
+    }
     // Check that the callback count is 0.
     EXPECT_EQ(0, GetCallbackCount());
     // Check that the timer is disabled if shared, enabled otherwise.
     if (timer_separate_) {
       EXPECT_TRUE(IsTimerEnabled());
     } else {
       EXPECT_FALSE(IsTimerEnabled());
     }
     // Verify that the ProfileHandler is not accumulating profile ticks.
     uint64 interrupts_before = GetInterruptCount();
@@ skipping 131 matching lines @@
   // Register a callback and check that profile ticks are being delivered.
   int tick_count;
   RegisterCallback(&tick_count);
   EXPECT_EQ(1, GetCallbackCount());
   VerifyRegistration(tick_count);
 
   // Register a second thread and verify that timer and signal handler are
   // correctly enabled.
   RegisterThread();
   EXPECT_EQ(1, GetCallbackCount());
-  EXPECT_TRUE(IsTimerEnabled());
-  EXPECT_TRUE(IsSignalEnabled());
+  EXPECT_EQ(FLAGS_test_profiler_enabled, IsTimerEnabled());
+  if (FLAGS_test_profiler_signal_handler) {
+    EXPECT_EQ(FLAGS_test_profiler_enabled, IsSignalEnabled());
+  }
 }
 
 }  // namespace
 
 int main(int argc, char** argv) {
   return ProfileHandlerTest::RUN_ALL_TESTS();
 }