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 48 matching lines @@
   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);
 
+  // Wait for the current time to advance beyond the creation stamp.
+  while (Time::Now().ToInternalValue() <= stamp)

[manzagop (departed), 2017/05/19 17:35:21]

Could you instead use a timestamp in the past when you
SetOwningProcessIdForTesting?

[bcwhite, 2017/05/19 18:04:07]

Done.

+    base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
+
   // 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