- Handle doubles transferred in message snapshots specially.

runtime/vm/dart_api_message.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/bigint_operations.h"
 #include "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
@@ skipping 440 matching lines @@
   intptr_t object_id = GetVMIsolateObjectId(value);
   if (object_id == kNullObject) {
     return AllocateDartCObjectNull();
   }
   if (object_id == kTrueValue) {
     return AllocateDartCObjectBool(true);
   }
   if (object_id == kFalseValue) {
     return AllocateDartCObjectBool(false);
   }
+  if (object_id == kDoubleObject) {
+    return AllocateDartCObjectDouble(ReadDouble());
+  }
   if (Symbols::IsVMSymbolId(object_id)) {
     return ReadVMSymbol(object_id);
   }
   // No other VM isolate objects are supported.
   return AllocateDartCObjectNull();
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInternalVMObject(intptr_t class_id,
                                                      intptr_t object_id) {
@@ skipping 59 matching lines @@
       Dart_CObject* object = AllocateDartCObjectBigint(len);
       AddBackRef(object_id, object, kIsDeserialized);
       char* p = object->value.as_bigint;
       for (intptr_t i = 0; i < len; i++) {
         p[i] = Read<uint8_t>();
       }
       p[len] = '\0';
       return object;
     }
     case kDoubleCid: {
-      // Read the double value for the object.
-      Dart_CObject* object = AllocateDartCObjectDouble(Read<double>());
-      AddBackRef(object_id, object, kIsDeserialized);
-      return object;
+      // Doubles are handled specially when being sent as part of message
+      // snapshots.
+      UNREACHABLE();
     }
     case kOneByteStringCid: {
       intptr_t len = ReadSmiValue();
       intptr_t hash = ReadSmiValue();
       USE(hash);
       uint8_t *latin1 =
           reinterpret_cast<uint8_t*>(::malloc(len * sizeof(uint8_t)));
       intptr_t utf8_len = 0;
       for (intptr_t i = 0; i < len; i++) {
         latin1[i] = Read<uint8_t>();
@@ skipping 492 matching lines @@
       WriteIntptrValue(0);
       // Write hex string length and content
       intptr_t len = strlen(hex_string);
       WriteIntptrValue(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       break;
     }
     case Dart_CObject_kDouble:
-      // Write out the serialization header value for this object.
-      WriteInlinedHeader(object);
-      // Write out the class and tags information.
-      WriteIndexedObject(kDoubleCid);
-      WriteIntptrValue(0);
-      // Write double value.
-      Write<double>(object->value.as_double);
+      WriteVMIsolateObject(kDoubleObject);
+      WriteDouble(object->value.as_double);
       break;
     case Dart_CObject_kString: {
       const uint8_t* utf8_str =
           reinterpret_cast<const uint8_t*>(object->value.as_string);
       intptr_t utf8_len = strlen(object->value.as_string);
       if (!Utf8::IsValid(utf8_str, utf8_len)) {
         return false;
       }
 
       Utf8::Type type;
@@ skipping 118 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart