Potentially fix the crash reported in Issue 10385

runtime/vm/heap_profiler.cc

 // Copyright (c) 2012, 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/heap_profiler.h"
 
 #include "vm/dart_api_state.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
@@ skipping 12 matching lines @@
   size_ += size;
 }
 
 
 void HeapProfiler::Buffer::EnsureCapacity(intptr_t size) {
   if ((size + size_) > capacity_) {
     intptr_t new_capacity = Utils::RoundUpToPowerOfTwo(capacity_ + size);
     uint8_t* new_data = new uint8_t[new_capacity];
     memmove(new_data, data_, size_);
     capacity_ = new_capacity;
+    delete[] data_;
     data_ = new_data;
   }
 }
 
 
 void HeapProfiler::Record::Write(const uint8_t* value, intptr_t size) {
   body_.Write(value, size);
 }
 
 
@@ skipping 207 matching lines @@
     case kArrayCid:
     case kImmutableArrayCid: {
       WriteObjectArrayDump(reinterpret_cast<const RawArray*>(raw_obj));
       break;
     }
     case kTypedDataInt8ArrayCid:
     case kTypedDataUint8ArrayCid:
     case kTypedDataUint8ClampedArrayCid: {
       const RawTypedData* raw_int8_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_int8_array,
-                              kByte,
-                              &raw_int8_array->data_[0]);
+      WritePrimitiveArrayDump(raw_int8_array, kByte);
       break;
     }
     case kTypedDataInt16ArrayCid:
     case kTypedDataUint16ArrayCid: {
       const RawTypedData* raw_int16_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_int16_array,
-                              kShort,
-                              &raw_int16_array->data_[0]);
+      WritePrimitiveArrayDump(raw_int16_array, kShort);
       break;
     }
     case kTypedDataInt32ArrayCid:
     case kTypedDataUint32ArrayCid: {
       const RawTypedData* raw_int32_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_int32_array,
-                              kInt,
-                              &raw_int32_array->data_[0]);
+      WritePrimitiveArrayDump(raw_int32_array, kInt);
       break;
     }
     case kTypedDataInt64ArrayCid:
     case kTypedDataUint64ArrayCid: {
       const RawTypedData* raw_int64_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_int64_array,
-                              kLong,
-                              &raw_int64_array->data_[0]);
+      WritePrimitiveArrayDump(raw_int64_array, kLong);
       break;
     }
     case kTypedDataFloat32ArrayCid: {
       const RawTypedData* raw_float32_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_float32_array,
-                              kFloat,
-                              &raw_float32_array->data_[0]);
+      WritePrimitiveArrayDump(raw_float32_array, kFloat);
       break;
     }
     case kTypedDataFloat64ArrayCid: {
       const RawTypedData* raw_float64_array =
           reinterpret_cast<const RawTypedData*>(raw_obj);
-      WritePrimitiveArrayDump(raw_float64_array,
-                              kDouble,
-                              &raw_float64_array->data_[0]);
+      WritePrimitiveArrayDump(raw_float64_array, kDouble);
       break;
     }
     case kOneByteStringCid:
     case kTwoByteStringCid:
     case kExternalOneByteStringCid:
     case kExternalTwoByteStringCid: {
       WriteInstanceDump(StringId(reinterpret_cast<const RawString*>(raw_obj)));
       break;
     }
     default:
@@ skipping 429 matching lines @@
 
 // PRIMITIVE ARRAY DUMP - 0x23
 //
 // Format:
 //  ID - array object ID
 //  u4 - stack trace serial number
 //  u4 - number of elements
 //  u1 - element type
 //  [u1]* - elements
 void HeapProfiler::WritePrimitiveArrayDump(const RawTypedData* raw_byte_array,
-                                           uint8_t tag,
-                                           const void* data) {
+                                           uint8_t tag) {
   SubRecord sub(kPrimitiveArrayDump, this);
   // array object ID
   sub.WriteObjectId(raw_byte_array);
   // stack trace serial number
   sub.Write32(0);
   // number of elements
   intptr_t length = Smi::Value(raw_byte_array->ptr()->length_);
+  const void* data = &(raw_byte_array->ptr()->data_[0]);
   sub.Write32(length);
   // element type
   sub.Write8(tag);
   // elements (packed)
   for (intptr_t i = 0; i < length; ++i) {
     if (tag == kByte) {
       sub.Write8(reinterpret_cast<const int8_t*>(data)[i]);
     } else if (tag == kShort) {
       sub.Write16(reinterpret_cast<const int16_t*>(data)[i]);
       break;
@@ skipping 35 matching lines @@
   RawObject* raw_obj = handle->raw();
   visitor_->VisitPointer(&raw_obj);
 }
 
 
 void HeapProfilerObjectVisitor::VisitObject(RawObject* raw_obj) {
   profiler_->WriteObject(raw_obj);
 }
 
 }  // namespace dart