Ensure clock advances in test between create and exit.

base/debug/activity_tracker_unittest.cc

 // Copyright 2016 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 "base/debug/activity_tracker.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 72 matching lines @@
   size_t GetGlobalUserDataMemoryCacheUsed() {
     return GlobalActivityTracker::Get()->user_data_allocator_.cache_used();
   }
 
   void HandleProcessExit(int64_t id,
                          int64_t stamp,
                          int code,
                          GlobalActivityTracker::ProcessPhase phase,
                          std::string&& command,
                          ActivityUserData::Snapshot&& data) {
-    exit_id = id;
-    exit_stamp = stamp;
-    exit_code = code;
-    exit_phase = phase;
-    exit_command = std::move(command);
-    exit_data = std::move(data);
+    exit_id_ = id;
+    exit_stamp_ = stamp;
+    exit_code_ = code;
+    exit_phase_ = phase;
+    exit_command_ = std::move(command);
+    exit_data_ = std::move(data);
   }
 
   static void DoNothing() {}
 
-  int64_t exit_id = 0;
-  int64_t exit_stamp;
-  int exit_code;
-  GlobalActivityTracker::ProcessPhase exit_phase;
-  std::string exit_command;
-  ActivityUserData::Snapshot exit_data;
+  int64_t exit_id_ = 0;
+  int64_t exit_stamp_;
+  int exit_code_;
+  GlobalActivityTracker::ProcessPhase exit_phase_;
+  std::string exit_command_;
+  ActivityUserData::Snapshot exit_data_;
 };
 
 TEST_F(ActivityTrackerTest, UserDataTest) {
   char buffer[256];
   memset(buffer, 0, sizeof(buffer));
   ActivityUserData data(buffer, sizeof(buffer));
   size_t space = sizeof(buffer) - sizeof(ActivityUserData::MemoryHeader);
   ASSERT_EQ(space, data.available_);
 
   data.SetInt("foo", 1);
@@ skipping 268 matching lines @@
   t2.WaitReady();
   EXPECT_EQ(starting_active + 1, GetGlobalActiveTrackerCount());
   EXPECT_EQ(starting_inactive, GetGlobalInactiveTrackerCount());
 
   t2.Exit();
   t2.Join();
   EXPECT_EQ(starting_active, GetGlobalActiveTrackerCount());
   EXPECT_EQ(starting_inactive + 1, GetGlobalInactiveTrackerCount());
 }
 
-// This test fails roughly 10% of runs on Android tablets.
-// See http://crbug.com/723060 for details.
-#if defined(OS_ANDROID)
-#define MAYBE_ProcessDeathTest DISABLED_ProcessDeathTest
-#else
-#define MAYBE_ProcessDeathTest ProcessDeathTest
-#endif
-
-TEST_F(ActivityTrackerTest, MAYBE_ProcessDeathTest) {
+TEST_F(ActivityTrackerTest, ProcessDeathTest) {
   // This doesn't actually create and destroy a process. Instead, it uses for-
   // testing interfaces to simulate data created by other processes.
   const ProcessId other_process_id = GetCurrentProcId() + 1;
 
   GlobalActivityTracker::CreateWithLocalMemory(kMemorySize, 0, "", 3, 0);
   GlobalActivityTracker* global = GlobalActivityTracker::Get();
   ThreadActivityTracker* thread = global->GetOrCreateTrackerForCurrentThread();
 
   // Get callbacks for process exit.
   global->SetProcessExitCallback(
@@ skipping 23 matching lines @@
       global->allocator()->GetAsReference(
           user_data.GetBaseAddress(),
           GlobalActivityTracker::kTypeIdUserDataRecord);
   ASSERT_TRUE(user_data_ref);
 
   // Make a copy of the thread-tracker state so it can be restored later.
   const size_t tracker_size = global->allocator()->GetAllocSize(tracker_ref);
   std::unique_ptr<char[]> tracker_copy(new char[tracker_size]);
   memcpy(tracker_copy.get(), thread->GetBaseAddress(), tracker_size);
 
-  // Change the objects to appear to be owned by another process.
+  // Change the objects to appear to be owned by another process. Use a "past"
+  // time so that exit-time is always later than create-time.
+  const int64_t past_stamp = Time::Now().ToInternalValue() - 1;
   int64_t owning_id;
   int64_t stamp;
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(
       global->process_data().GetBaseAddress(), &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
   ASSERT_TRUE(ThreadActivityTracker::GetOwningProcessId(
       thread->GetBaseAddress(), &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(user_data.GetBaseAddress(),
                                                    &owning_id, &stamp));
   EXPECT_NE(other_process_id, owning_id);
-  global->process_data().SetOwningProcessIdForTesting(other_process_id, stamp);
-  thread->SetOwningProcessIdForTesting(other_process_id, stamp);
-  user_data.SetOwningProcessIdForTesting(other_process_id, stamp);
+  global->process_data().SetOwningProcessIdForTesting(other_process_id,
+                                                      past_stamp);
+  thread->SetOwningProcessIdForTesting(other_process_id, past_stamp);
+  user_data.SetOwningProcessIdForTesting(other_process_id, past_stamp);
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(
       global->process_data().GetBaseAddress(), &owning_id, &stamp));
   EXPECT_EQ(other_process_id, owning_id);
   ASSERT_TRUE(ThreadActivityTracker::GetOwningProcessId(
       thread->GetBaseAddress(), &owning_id, &stamp));
   EXPECT_EQ(other_process_id, owning_id);
   ASSERT_TRUE(ActivityUserData::GetOwningProcessId(user_data.GetBaseAddress(),
                                                    &owning_id, &stamp));
   EXPECT_EQ(other_process_id, owning_id);
 
   // Check that process exit will perform callback and free the allocations.
-  ASSERT_EQ(0, exit_id);
+  ASSERT_EQ(0, exit_id_);
   ASSERT_EQ(GlobalActivityTracker::kTypeIdProcessDataRecord,
             global->allocator()->GetType(proc_data_ref));
   ASSERT_EQ(GlobalActivityTracker::kTypeIdActivityTracker,
             global->allocator()->GetType(tracker_ref));
   ASSERT_EQ(GlobalActivityTracker::kTypeIdUserDataRecord,
             global->allocator()->GetType(user_data_ref));
   global->RecordProcessExit(other_process_id, 0);
-  EXPECT_EQ(other_process_id, exit_id);
-  EXPECT_EQ("foo --bar", exit_command);
+  EXPECT_EQ(other_process_id, exit_id_);
+  EXPECT_EQ("foo --bar", exit_command_);
   EXPECT_EQ(GlobalActivityTracker::kTypeIdProcessDataRecordFree,
             global->allocator()->GetType(proc_data_ref));
   EXPECT_EQ(GlobalActivityTracker::kTypeIdActivityTrackerFree,
             global->allocator()->GetType(tracker_ref));
   EXPECT_EQ(GlobalActivityTracker::kTypeIdUserDataRecordFree,
             global->allocator()->GetType(user_data_ref));
 
   // Restore memory contents and types so things don't crash when doing real
   // process clean-up.
   memcpy(const_cast<void*>(thread->GetBaseAddress()), tracker_copy.get(),
          tracker_size);
   global->allocator()->ChangeType(
       proc_data_ref, GlobalActivityTracker::kTypeIdProcessDataRecord,
       GlobalActivityTracker::kTypeIdUserDataRecordFree, false);
   global->allocator()->ChangeType(
       tracker_ref, GlobalActivityTracker::kTypeIdActivityTracker,
       GlobalActivityTracker::kTypeIdActivityTrackerFree, false);
   global->allocator()->ChangeType(
       user_data_ref, GlobalActivityTracker::kTypeIdUserDataRecord,
       GlobalActivityTracker::kTypeIdUserDataRecordFree, false);
 }
 
 }  // namespace debug
 }  // namespace base