NativeStackSampler implementation for Mac.

base/profiler/stack_sampling_profiler_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <cstdlib>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "base/profiler/native_stack_sampler.h"
 #include "base/profiler/stack_sampling_profiler.h"
 #include "base/run_loop.h"
 #include "base/scoped_native_library.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
 #include <intrin.h>
 #include <malloc.h>
 #include <windows.h>
 #else
 #include <alloca.h>
 #endif
 
 // STACK_SAMPLING_PROFILER_SUPPORTED is used to conditionally enable the tests
-// below for supported platforms (currently Win x64).
-#if defined(_WIN64)
+// below for supported platforms (currently Win x64 and Mac x64).
+#if defined(_WIN64) || defined(OS_MACOSX)
 #define STACK_SAMPLING_PROFILER_SUPPORTED 1
 #endif
 
 #if defined(OS_WIN)
 #pragma intrinsic(_ReturnAddress)
 #endif
 
 namespace base {
 
 using SamplingParams = StackSamplingProfiler::SamplingParams;
@@ skipping 246 matching lines @@
   uintptr_t module_base_address = reinterpret_cast<uintptr_t>(library);
   HMODULE module_handle;
   // Keep trying to get the module handle until the call fails.
   while (::GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                              GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                              reinterpret_cast<LPCTSTR>(module_base_address),
                              &module_handle) ||
          ::GetLastError() != ERROR_MOD_NOT_FOUND) {
     PlatformThread::Sleep(TimeDelta::FromMilliseconds(1));
   }
+#elif defined(OS_MACOSX)
+  // Unloading a library on the Mac is synchronous.
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 // Called on the profiler thread when complete, to collect profiles.
 void SaveProfiles(CallStackProfiles* profiles,
                   CallStackProfiles pending_profiles) {
   *profiles = std::move(pending_profiles);
 }
@@ skipping 216 matching lines @@
     // SignalAndWaitUntilSignaled. The frame in the now-unloaded library is not
     // recorded since we can't get module information.
     //
     // ... WaitableEvent and system frames ...
     // TargetThread::SignalAndWaitUntilSignaled
     // TargetThread::OtherLibraryCallback
     EXPECT_EQ(2, sample.frames.end() - end_frame)
         << "Stack:\n"
         << FormatSampleForDiagnosticOutput(sample, profile.modules);
   } else {
-    // We didn't wait for the asynchonous unloading to complete, so the results
+    // We didn't wait for the asynchronous unloading to complete, so the results
     // are non-deterministic: if the library finished unloading we should have
     // the same stack as |wait_until_unloaded|, if not we should have the full
     // stack. The important thing is that we should not crash.
 
     if (sample.frames.end() - end_frame == 2) {
       // This is the same case as |wait_until_unloaded|.
       return;
     }
 
     // Check that the stack contains a frame for
@@ skipping 59 matching lines @@
   Frames::const_iterator loc = FindFirstFrameWithinFunction(
       sample, &TargetThread::SignalAndWaitUntilSignaled);
   ASSERT_TRUE(loc != sample.frames.end())
       << "Function at "
       << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
              &TargetThread::SignalAndWaitUntilSignaled))
       << " was not found in stack:\n"
       << FormatSampleForDiagnosticOutput(sample, profile.modules);
   FilePath executable_path;
   EXPECT_TRUE(PathService::Get(FILE_EXE, &executable_path));
-  EXPECT_EQ(executable_path, profile.modules[loc->module_index].filename);
+  EXPECT_EQ(executable_path,
+            MakeAbsoluteFilePath(profile.modules[loc->module_index].filename));
 }
 
 // Checks that annotations are recorded in samples.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_Annotations Annotations
 #else
 #define MAYBE_Annotations DISABLED_Annotations
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_Annotations) {
   StackSamplingProfiler::ResetAnnotationsForTesting();
@@ skipping 360 matching lines @@
   // TargetThread::SignalAndWaitUntilSignaled
   // TargetThread::OtherLibraryCallback
   // InvokeCallbackFunction (in other library)
   // TargetThread::CallThroughOtherLibrary
   EXPECT_EQ(3, other_library_frame - end_frame)
       << "Stack:\n" << FormatSampleForDiagnosticOutput(sample, profile.modules);
 }
 
 // Checks that a stack that runs through a library that is unloading produces a
 // stack, and doesn't crash.
-#if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
+// Unloading is synchronous on the Mac, so this test is inapplicable.
+#if defined(STACK_SAMPLING_PROFILER_SUPPORTED) && !defined(OS_MACOSX)
 #define MAYBE_UnloadingLibrary UnloadingLibrary
 #else
 #define MAYBE_UnloadingLibrary DISABLED_UnloadingLibrary
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_UnloadingLibrary) {
   TestLibraryUnload(false);
 }
 
 // Checks that a stack that runs through a library that has been unloaded
 // produces a stack, and doesn't crash.
 #if defined(STACK_SAMPLING_PROFILER_SUPPORTED)
 #define MAYBE_UnloadedLibrary UnloadedLibrary
 #else
 #define MAYBE_UnloadedLibrary DISABLED_UnloadedLibrary
 #endif
 TEST(StackSamplingProfilerTest, MAYBE_UnloadedLibrary) {
   TestLibraryUnload(true);
 }
 
 }  // namespace base