Adds some code to help isolate where crash is happening

mojo/message_pump/handle_watcher_unittest.cc

 // Copyright 2013 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 "mojo/message_pump/handle_watcher.h"
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/auto_reset.h"
@@ skipping 134 matching lines @@
 
 INSTANTIATE_TEST_CASE_P(
     MultipleMessageLoopConfigs, HandleWatcherTest,
     testing::Values(MESSAGE_LOOP_CONFIG_DEFAULT, MESSAGE_LOOP_CONFIG_MOJO));
 
 // Trivial test case with a single handle to watch.
 TEST_P(HandleWatcherTest, SingleHandler) {
   MessagePipe test_pipe;
   ASSERT_TRUE(test_pipe.handle0.is_valid());
   CallbackHelper callback_helper;
-  HandleWatcher watcher;
+  HandleWatcher watcher(0);
   callback_helper.Start(&watcher, test_pipe.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper.got_callback());
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle1.get(),
                                            std::string()));
   callback_helper.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper.got_callback());
 }
 
 // Creates three handles and notfies them in reverse order ensuring each one is
 // notified appropriately.
 TEST_P(HandleWatcherTest, ThreeHandles) {
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   MessagePipe test_pipe3;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   CallbackHelper callback_helper3;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
   ASSERT_TRUE(test_pipe3.handle0.is_valid());
 
-  HandleWatcher watcher1;
+  HandleWatcher watcher1(0);
   callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
-  HandleWatcher watcher2;
+  HandleWatcher watcher2(0);
   callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
-  HandleWatcher watcher3;
+  HandleWatcher watcher3(0);
   callback_helper3.Start(&watcher3, test_pipe3.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
   // Write to 3 and make sure it's notified.
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe3.handle1.get(),
                                            std::string()));
   callback_helper3.RunUntilGotCallback();
@@ skipping 27 matching lines @@
 
 // Verifies Start() invoked a second time works.
 TEST_P(HandleWatcherTest, Restart) {
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
 
-  HandleWatcher watcher1;
+  HandleWatcher watcher1(0);
   callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
 
-  HandleWatcher watcher2;
+  HandleWatcher watcher2(0);
   callback_helper2.Start(&watcher2, test_pipe2.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
 
   // Write to 1 and make sure it's notified.
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe1.handle1.get(),
                                            std::string()));
   callback_helper1.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper1.got_callback());
@@ skipping 22 matching lines @@
   EXPECT_TRUE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
 }
 
 // Verifies Start() invoked a second time on the same handle works.
 TEST_P(HandleWatcherTest, RestartOnSameHandle) {
   MessagePipe test_pipe;
   CallbackHelper callback_helper;
   ASSERT_TRUE(test_pipe.handle0.is_valid());
 
-  HandleWatcher watcher;
+  HandleWatcher watcher(0);
   callback_helper.Start(&watcher, test_pipe.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper.got_callback());
 
   callback_helper.Start(&watcher, test_pipe.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper.got_callback());
 }
 
 // Verifies deadline is honored.
 TEST_P(HandleWatcherTest, Deadline) {
   InstallTickClock();
 
   MessagePipe test_pipe1;
   MessagePipe test_pipe2;
   MessagePipe test_pipe3;
   CallbackHelper callback_helper1;
   CallbackHelper callback_helper2;
   CallbackHelper callback_helper3;
   ASSERT_TRUE(test_pipe1.handle0.is_valid());
   ASSERT_TRUE(test_pipe2.handle0.is_valid());
   ASSERT_TRUE(test_pipe3.handle0.is_valid());
 
   // Add a watcher with an infinite timeout.
-  HandleWatcher watcher1;
+  HandleWatcher watcher1(0);
   callback_helper1.Start(&watcher1, test_pipe1.handle0.get());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
   // Add another watcher wth a timeout of 500 microseconds.
-  HandleWatcher watcher2;
+  HandleWatcher watcher2(0);
   watcher2.Start(test_pipe2.handle0.get(), MOJO_HANDLE_SIGNAL_READABLE, 500,
                  callback_helper2.GetCallback());
   RunUntilIdle();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_FALSE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 
   // Advance the clock passed the deadline. We also have to start another
   // watcher to wake up the background thread.
   tick_clock_.Advance(base::TimeDelta::FromMicroseconds(501));
 
-  HandleWatcher watcher3;
+  HandleWatcher watcher3(0);
   callback_helper3.Start(&watcher3, test_pipe3.handle0.get());
 
   callback_helper2.RunUntilGotCallback();
   EXPECT_FALSE(callback_helper1.got_callback());
   EXPECT_TRUE(callback_helper2.got_callback());
   EXPECT_FALSE(callback_helper3.got_callback());
 }
 
 TEST_P(HandleWatcherTest, DeleteInCallback) {
   MessagePipe test_pipe;
   CallbackHelper callback_helper;
 
-  HandleWatcher* watcher = new HandleWatcher();
+  HandleWatcher* watcher = new HandleWatcher(0);
   callback_helper.StartWithCallback(watcher, test_pipe.handle1.get(),
                                     base::Bind(&DeleteWatcherAndForwardResult,
                                                watcher,
                                                callback_helper.GetCallback()));
   EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle0.get(),
                                            std::string()));
   callback_helper.RunUntilGotCallback();
   EXPECT_TRUE(callback_helper.got_callback());
 }
 
 TEST_P(HandleWatcherTest, AbortedOnMessageLoopDestruction) {
   bool was_signaled = false;
   MojoResult result = MOJO_RESULT_OK;
 
   MessagePipe pipe;
-  HandleWatcher watcher;
+  HandleWatcher watcher(0);
   watcher.Start(pipe.handle0.get(),
                 MOJO_HANDLE_SIGNAL_READABLE,
                 MOJO_DEADLINE_INDEFINITE,
                 base::Bind(&ObserveCallback, &was_signaled, &result));
 
   // Now, let the MessageLoop get torn down. We expect our callback to run.
   TearDownMessageLoop();
 
   EXPECT_TRUE(was_signaled);
   EXPECT_EQ(MOJO_RESULT_ABORTED, result);
@@ skipping 16 matching lines @@
 // |count| is the number of HandleWatchers to create. |active_count| is the
 // number of outstanding threads, |task_runner| the task runner for the main
 // thread and |run_loop| the run loop that should be quit when there are no more
 // threads running. When done StressThreadDone() is invoked on the main thread.
 // |active_count| and |run_loop| should only be used on the main thread.
 void RunStressTest(int count,
                    scoped_refptr<base::TaskRunner> task_runner,
                    base::RunLoop* run_loop,
                    int* active_count) {
   struct TestData {
+    TestData() : watcher(0) {}
+
     MessagePipe pipe;
     HandleWatcher watcher;
   };
   ScopedVector<TestData> data_vector;
   for (int i = 0; i < count; ++i) {
     if (i % 20 == 0) {
       // Every so often we wait. This results in some level of thread balancing
       // as well as making sure HandleWatcher has time to actually start some
       // watches.
       MessagePipe test_pipe;
       ASSERT_TRUE(test_pipe.handle0.is_valid());
       CallbackHelper callback_helper;
-      HandleWatcher watcher;
+      HandleWatcher watcher(0);
       callback_helper.Start(&watcher, test_pipe.handle0.get());
       RunUntilIdle();
       EXPECT_FALSE(callback_helper.got_callback());
       EXPECT_TRUE(mojo::test::WriteTextMessage(test_pipe.handle1.get(),
                                                std::string()));
       base::MessageLoop::ScopedNestableTaskAllower scoper(
           base::MessageLoop::current());
       callback_helper.RunUntilGotCallback();
       EXPECT_TRUE(callback_helper.got_callback());
     } else {
@@ skipping 51 matching lines @@
                               message_loop.task_runner(),
                               &run_loop, &threads_active_counter));
   }
   run_loop.Run();
   ASSERT_EQ(0, threads_active_counter);
 }
 
 }  // namespace test
 }  // namespace common
 }  // namespace mojo