Stack sampling profiler: handle unloaded and unloading modules

base/profiler/stack_sampling_profiler.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/stack_sampling_profiler.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 199 matching lines @@
 // StackSamplingProfiler ------------------------------------------------------
 
 StackSamplingProfiler::SamplingParams::SamplingParams()
     : initial_delay(TimeDelta::FromMilliseconds(0)),
       bursts(1),
       burst_interval(TimeDelta::FromMilliseconds(10000)),
       samples_per_burst(300),
       sampling_interval(TimeDelta::FromMilliseconds(100)) {
 }
 
-StackSamplingProfiler::StackSamplingProfiler(PlatformThreadId thread_id,
-                                             const SamplingParams& params,
-                                             const CompletedCallback& callback)
-    : thread_id_(thread_id), params_(params), completed_callback_(callback) {}
+StackSamplingProfiler::StackSamplingProfiler(
+    PlatformThreadId thread_id,
+    const SamplingParams& params,
+    const CompletedCallback& callback)
+    : StackSamplingProfiler(thread_id, params, callback, nullptr) {}
+
+StackSamplingProfiler::StackSamplingProfiler(
+    PlatformThreadId thread_id,
+    const SamplingParams& params,
+    const CompletedCallback& callback,
+    NativeStackSamplerTestDelegate* test_delegate)
+    : thread_id_(thread_id), params_(params), completed_callback_(callback),
+      test_delegate_(test_delegate) {
+}
 
 StackSamplingProfiler::~StackSamplingProfiler() {
   Stop();
   if (!sampling_thread_handle_.is_null())
     PlatformThread::Join(sampling_thread_handle_);
 }
 
 // static
 void StackSamplingProfiler::StartAndRunAsync(
     PlatformThreadId thread_id,
     const SamplingParams& params,
     const CompletedCallback& callback) {
   CHECK(ThreadTaskRunnerHandle::Get());
   AsyncRunner::Run(thread_id, params, callback);
 }
 
 void StackSamplingProfiler::Start() {
   if (completed_callback_.is_null())
     return;
 
   scoped_ptr<NativeStackSampler> native_sampler =
-      NativeStackSampler::Create(thread_id_);
+      NativeStackSampler::Create(thread_id_, test_delegate_);
   if (!native_sampler)
     return;
 
   sampling_thread_.reset(
       new SamplingThread(native_sampler.Pass(), params_, completed_callback_));
   if (!PlatformThread::Create(0, sampling_thread_.get(),
                               &sampling_thread_handle_))
     sampling_thread_.reset();
 }
 
@@ skipping 11 matching lines @@
 }
 
 bool operator<(const StackSamplingProfiler::Frame &a,
                const StackSamplingProfiler::Frame &b) {
   return (a.module_index < b.module_index) ||
       (a.module_index == b.module_index &&
        a.instruction_pointer < b.instruction_pointer);
 }
 
 }  // namespace base