Revert of NativeStackSampler implementation for Mac.

base/profiler/native_stack_sampler_win.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 "base/profiler/native_stack_sampler.h"
 
 #include <objbase.h>
 #include <windows.h>
 #include <stddef.h>
 #include <winternl.h>
@@ skipping 380 matching lines @@
                         NativeStackSamplerTestDelegate* test_delegate);
   ~NativeStackSamplerWin() override;
 
   // StackSamplingProfiler::NativeStackSampler:
   void ProfileRecordingStarting(
       std::vector<StackSamplingProfiler::Module>* modules) override;
   void RecordStackSample(StackSamplingProfiler::Sample* sample) override;
   void ProfileRecordingStopped() override;
 
  private:
-  // Intended to hold the largest stack used by Chrome. The default Win32
-  // reserved stack size is 1 MB and Chrome Windows threads currently always
-  // use the default, but this allows for expansion if it occurs. The size
-  // beyond the actual stack size consists of unallocated virtual memory pages
-  // so carries little cost (just a bit of wasted address space).
-  static constexpr size_t kStackCopyBufferSize = 2 * 1024 * 1024;
+  enum {
+    // Intended to hold the largest stack used by Chrome. The default Win32
+    // reserved stack size is 1 MB and Chrome Windows threads currently always
+    // use the default, but this allows for expansion if it occurs. The size
+    // beyond the actual stack size consists of unallocated virtual memory pages
+    // so carries little cost (just a bit of wasted address space).
+    kStackCopyBufferSize = 2 * 1024 * 1024
+  };
 
   // Attempts to query the module filename, base address, and id for
   // |module_handle|, and store them in |module|. Returns true if it succeeded.
   static bool GetModuleForHandle(HMODULE module_handle,
                                  StackSamplingProfiler::Module* module);
 
   // Gets the index for the Module corresponding to |module_handle| in
   // |modules|, adding it if it's not already present. Returns
   // StackSamplingProfiler::Frame::kUnknownModuleIndex if no Module can be
   // determined for |module|.
@@ skipping 48 matching lines @@
 void NativeStackSamplerWin::ProfileRecordingStarting(
     std::vector<StackSamplingProfiler::Module>* modules) {
   current_modules_ = modules;
   profile_module_index_.clear();
 }
 
 void NativeStackSamplerWin::RecordStackSample(
     StackSamplingProfiler::Sample* sample) {
   DCHECK(current_modules_);
 
+  if (!stack_copy_buffer_)
+    return;
+
   std::vector<RecordedFrame> stack;
   SuspendThreadAndRecordStack(thread_handle_.Get(), thread_stack_base_address_,
                               stack_copy_buffer_.get(), kStackCopyBufferSize,
                               &stack, annotator_, sample, test_delegate_);
   CopyToSample(stack, sample, current_modules_);
 }
 
 void NativeStackSamplerWin::ProfileRecordingStopped() {
   current_modules_ = nullptr;
 }
@@ skipping 67 matching lines @@
 
   if (thread_handle) {
     return std::unique_ptr<NativeStackSampler>(new NativeStackSamplerWin(
         win::ScopedHandle(thread_handle), annotator, test_delegate));
   }
 #endif
   return std::unique_ptr<NativeStackSampler>();
 }
 
 }  // namespace base