Revert "Updated MallocHooks to collect stack traces when memory is allocated."

runtime/vm/profiler_service.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/hash_map.h"
 #include "vm/log.h"
 #include "vm/native_symbol.h"
@@ skipping 2652 matching lines @@
       profile.PrintTimelineJSON(stream);
     } else {
       profile.PrintProfileJSON(stream);
     }
   }
 }
 
 
 class NoAllocationSampleFilter : public SampleFilter {
  public:
-  NoAllocationSampleFilter(Dart_Port port,
+  NoAllocationSampleFilter(Isolate* isolate,
                            intptr_t thread_task_mask,
                            int64_t time_origin_micros,
                            int64_t time_extent_micros)
-      : SampleFilter(port,
+      : SampleFilter(isolate,
                      thread_task_mask,
                      time_origin_micros,
                      time_extent_micros) {}
 
-  bool FilterSample(Sample* sample) {
-    return !sample->is_allocation_sample() &&
-           !sample->is_native_allocation_sample();
-  }
+  bool FilterSample(Sample* sample) { return !sample->is_allocation_sample(); }
 };
 
 
 void ProfilerService::PrintJSON(JSONStream* stream,
                                 Profile::TagOrder tag_order,
                                 intptr_t extra_tags,
                                 int64_t time_origin_micros,
                                 int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  NoAllocationSampleFilter filter(isolate->main_port(), Thread::kMutatorTask,
+  NoAllocationSampleFilter filter(isolate, Thread::kMutatorTask,
                                   time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, extra_tags, &filter, as_timeline);
 }
 
 
 class ClassAllocationSampleFilter : public SampleFilter {
  public:
-  ClassAllocationSampleFilter(Dart_Port port,
+  ClassAllocationSampleFilter(Isolate* isolate,
                               const Class& cls,
                               intptr_t thread_task_mask,
                               int64_t time_origin_micros,
                               int64_t time_extent_micros)
-      : SampleFilter(port,
+      : SampleFilter(isolate,
                      thread_task_mask,
                      time_origin_micros,
                      time_extent_micros),
         cls_(Class::Handle(cls.raw())) {
     ASSERT(!cls_.IsNull());
   }
 
   bool FilterSample(Sample* sample) {
     return sample->is_allocation_sample() &&
            (sample->allocation_cid() == cls_.id());
   }
 
  private:
   const Class& cls_;
 };
 
 
-class NativeAllocationSampleFilter : public SampleFilter {
- public:
-  NativeAllocationSampleFilter(intptr_t thread_task_mask,
-                               int64_t time_origin_micros,
-                               int64_t time_extent_micros)
-      : SampleFilter(ILLEGAL_PORT,
-                     thread_task_mask,
-                     time_origin_micros,
-                     time_extent_micros) {}
-  bool FilterSample(Sample* sample) {
-    return sample->is_native_allocation_sample();
-  }
-};
-
-
 void ProfilerService::PrintAllocationJSON(JSONStream* stream,
                                           Profile::TagOrder tag_order,
                                           const Class& cls,
                                           int64_t time_origin_micros,
                                           int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
-  ClassAllocationSampleFilter filter(isolate->main_port(), cls,
-                                     Thread::kMutatorTask, time_origin_micros,
-                                     time_extent_micros);
+  ClassAllocationSampleFilter filter(isolate, cls, Thread::kMutatorTask,
+                                     time_origin_micros, time_extent_micros);
   const bool as_timeline = false;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
-
-
-void ProfilerService::PrintNativeAllocationJSON(JSONStream* stream,
-                                                Profile::TagOrder tag_order,
-                                                int64_t time_origin_micros,
-                                                int64_t time_extent_micros) {
-  Thread* thread = Thread::Current();
-  const intptr_t thread_task_mask = Thread::kMutatorTask |
-                                    Thread::kCompilerTask |
-                                    Thread::kSweeperTask | Thread::kMarkerTask;
-  NativeAllocationSampleFilter filter(thread_task_mask, time_origin_micros,
-                                      time_extent_micros);
-  const bool as_timeline = false;
-  PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
-}
 
 
 void ProfilerService::PrintTimelineJSON(JSONStream* stream,
                                         Profile::TagOrder tag_order,
                                         int64_t time_origin_micros,
                                         int64_t time_extent_micros) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   const intptr_t thread_task_mask = Thread::kMutatorTask |
                                     Thread::kCompilerTask |
                                     Thread::kSweeperTask | Thread::kMarkerTask;
-  NoAllocationSampleFilter filter(isolate->main_port(), thread_task_mask,
-                                  time_origin_micros, time_extent_micros);
+  NoAllocationSampleFilter filter(isolate, thread_task_mask, time_origin_micros,
+                                  time_extent_micros);
   const bool as_timeline = true;
   PrintJSONImpl(thread, stream, tag_order, kNoExtraTags, &filter, as_timeline);
 }
 
 
 void ProfilerService::ClearSamples() {
   SampleBuffer* sample_buffer = Profiler::sample_buffer();
   if (sample_buffer == NULL) {
     return;
   }
 
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
 
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart