Added page to Observatory to display native memory allocation information.

runtime/observatory/lib/src/repositories/sample_profile.dart

 // Copyright (c) 2016, 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
 
 part of repositories;
 
 String _tagToString(M.SampleProfileTag tag) {
   switch (tag) {
     case M.SampleProfileTag.userVM:
       return 'UserVM';
@@ skipping 14 matching lines @@
   final SampleProfileLoadingProgress progress;
   SampleProfileLoadingProgressEvent(this.progress);
 }
 
 class SampleProfileLoadingProgress extends M.SampleProfileLoadingProgress {
   StreamController<SampleProfileLoadingProgressEvent> _onProgress =
       new StreamController<SampleProfileLoadingProgressEvent>.broadcast();
   Stream<SampleProfileLoadingProgressEvent> get onProgress =>
       _onProgress.stream;
 
-  final S.Isolate isolate;
+  final Object owner;

[Cutch, 2017/03/21 20:27:11]

Use the type ServiceObjectOwner instead of Object (here and elsewhere)

[bkonyi, 2017/03/22 21:25:21]

Done.

   final S.Class cls;
   final M.SampleProfileTag tag;
   final bool clear;
+  final bool isCpuProfile;

[Cutch, 2017/03/21 20:27:11]

isn't there an enum for the profile type? Use that instead of the bool here to
be more generic in the future.

[bkonyi, 2017/03/22 21:25:21]

Done.

 
   M.SampleProfileLoadingStatus _status = M.SampleProfileLoadingStatus.fetching;
   double _progress = 0.0;
   final Stopwatch _fetchingTime = new Stopwatch();
   final Stopwatch _loadingTime = new Stopwatch();
   CpuProfile _profile;
 
   M.SampleProfileLoadingStatus get status => _status;
   double get progress => _progress;
   Duration get fetchingTime => _fetchingTime.elapsed;
   Duration get loadingTime => _loadingTime.elapsed;
   CpuProfile get profile => _profile;
 
-  SampleProfileLoadingProgress(this.isolate, this.tag, this.clear, {this.cls}) {
+  SampleProfileLoadingProgress(this.owner, this.tag, this.clear,
+      {this.isCpuProfile: true, this.cls}) {
     _run();
   }
 
   Future _run() async {
     _fetchingTime.start();
     try {
-      if (clear) {
-        await isolate.invokeRpc('_clearCpuProfile', {});
+      if (clear && isCpuProfile) {
+        await owner.invokeRpc('_clearCpuProfile', {});
       }
 
-      final response = cls != null
+      var response;
+      if (isCpuProfile) {
+        response = cls != null
           ? await cls.getAllocationSamples(_tagToString(tag))
-          : await isolate
+          : await owner
               .invokeRpc('_getCpuProfile', {'tags': _tagToString(tag)});
+      } else {
+        assert(owner is M.VM);
+        M.VM vm = owner as M.VM;
+        response = await owner.invokeRpc('_getNativeAllocationSamples', {'tags':
+          _tagToString(tag)});
+      }
 
       _fetchingTime.stop();
       _loadingTime.start();
       _status = M.SampleProfileLoadingStatus.loading;
       _triggerOnProgress();
 
       CpuProfile profile = new CpuProfile();
 
-      Stream<double> progress = profile.loadProgress(isolate, response);
+      Stream<double> progress = profile.loadProgress(owner, response);
       progress.listen((value) {
         _progress = value;
         _triggerOnProgress();
       });
 
       await progress.drain();
 
       profile.buildFunctionCallerAndCallees();
       _profile = profile;
 
@@ skipping 31 matching lines @@
     implements M.IsolateSampleProfileRepository {
   SampleProfileLoadingProgress _last;
 
   Stream<SampleProfileLoadingProgressEvent> get(
       M.IsolateRef i, M.SampleProfileTag t,
       {bool clear: false, bool forceFetch: false}) {
     assert(clear != null);
     assert(forceFetch != null);
     S.Isolate isolate = i as S.Isolate;
     assert(isolate != null);
-    if (_last != null && !clear && !forceFetch && _last.isolate == isolate) {
+    if (_last != null && !clear && !forceFetch && _last.owner == isolate) {
       _last.reuse();
     } else {
       _last = new SampleProfileLoadingProgress(isolate, t, clear);
     }
     return _last.onProgress;
   }
 }
 
 class ClassSampleProfileRepository implements M.ClassSampleProfileRepository {
   Stream<SampleProfileLoadingProgressEvent> get(
@@ skipping 11 matching lines @@
     assert(cls != null);
     return cls.setTraceAllocations(true);
   }
 
   Future disable(M.IsolateRef i, M.ClassRef c) {
     S.Class cls = c as S.Class;
     assert(cls != null);
     return cls.setTraceAllocations(false);
   }
 }
+
+class NativeMemorySampleProfileRepository
+    implements M.NativeMemorySampleProfileRepository {
+  SampleProfileLoadingProgress _last;
+
+  Stream<SampleProfileLoadingProgressEvent> get(
+      M.VM vm, M.SampleProfileTag t, {bool forceFetch: false}) {
+    assert(forceFetch != null);
+    if (_last != null && !clear && !forceFetch) {
+      _last.reuse();
+    } else {
+      _last = new SampleProfileLoadingProgress(vm, t, false, isCpuProfile: false
+          );
+    }
+    return _last.onProgress;
+  }
+}
+