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() - 1) - end_frame == 2) {
       // This is the same case as |wait_until_unloaded|.

[Avi (use Gerrit), 2017/02/16 06:11:15]

FYI this isn't the same as above.

Above is:

EXPECT_EQ(2, sample.frames.end() - end_frame)

whereas this takes one off the end and still expects it to be 2.

[Mike Wittman, 2017/02/16 21:51:34]

Good catch. This should be just "if (sample.frames.end() - end_frame == 2)". Can
you make the change?

Something must have changed in the test execution or the system libraries since
this was implemented, because I remember being forced to address it due to flaky
failures when it was originally implemented. I'm guessing the inconsistency was
due to an update to the above condition that didn't get propagated here and was
never noticed because the path isn't being triggered.

[Avi (use Gerrit), 2017/02/17 03:41:09]

Spinning off into a separate review.

       return;
     }
 
     // Check that the stack contains a frame for
     // TargetThread::CallThroughOtherLibrary().
     Frames::const_iterator other_library_frame = FindFirstFrameWithinFunction(
         sample, &TargetThread::CallThroughOtherLibrary);
     ASSERT_TRUE(other_library_frame != sample.frames.end())
         << "Function at "
         << MaybeFixupFunctionAddressForILT(reinterpret_cast<const void*>(
@@ skipping 53 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