Add external sizes to the heap dominator tree.

runtime/vm/object_graph.cc

 // Copyright (c) 2014, 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/object_graph.h"
 
 #include "vm/dart.h"
+#include "vm/dart_api_state.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/raw_object.h"
 #include "vm/reusable_handles.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
@@ skipping 571 matching lines @@
 
   intptr_t count() const { return count_; }
 
  private:
   WriteStream* stream_;
   WritePointerVisitor ptr_writer_;
   ObjectGraph::SnapshotRoots roots_;
   intptr_t count_;
 };
 
+class WriteGraphExternalSizesVisitor : public HandleVisitor {
+ public:
+  WriteGraphExternalSizesVisitor(Thread* thread, WriteStream* stream)
+      : HandleVisitor(thread), stream_(stream) {}
+
+  void VisitHandle(uword addr) {
+    FinalizablePersistentHandle* weak_persistent_handle =
+        reinterpret_cast<FinalizablePersistentHandle*>(addr);
+    if (!weak_persistent_handle->raw()->IsHeapObject()) {
+      return;  // Free handle.
+    }
+
+    WritePtr(weak_persistent_handle->raw(), stream_);
+    stream_->WriteUnsigned(weak_persistent_handle->external_size());
+  }
+
+ private:
+  WriteStream* stream_;
+};
+
 intptr_t ObjectGraph::Serialize(WriteStream* stream,
                                 SnapshotRoots roots,
                                 bool collect_garbage) {
   if (collect_garbage) {
     isolate()->heap()->CollectAllGarbage();
   }
   // Current encoding assumes objects do not move, so promote everything to old.
   isolate()->heap()->new_space()->Evacuate();
   HeapIterationScope iteration_scope(Thread::Current(), true);
 
@@ skipping 25 matching lines @@
       // Write stack "object".
       WriteHeader(kStackAddress, 0, kStackCid, stream);
       WritePointerVisitor ptr_writer(isolate(), stream, true);
       isolate()->VisitStackPointers(&ptr_writer, false);
       stream->WriteUnsigned(0);
     }
   }
 
   WriteGraphVisitor visitor(isolate(), stream, roots);
   IterateObjects(&visitor);
+  stream->WriteUnsigned(0);
+
+  WriteGraphExternalSizesVisitor external_visitor(Thread::Current(), stream);
+  isolate()->VisitWeakPersistentHandles(&external_visitor);
+  stream->WriteUnsigned(0);
 
   intptr_t object_count = visitor.count();
   if (roots == kVM) {
     object_count += 1;  // root
   } else {
     object_count += 2;  // root and stack
   }
   return object_count;
 }
 
 }  // namespace dart