ValueSerializer: Expose reading/writing doubles to embedder.

BUG=chromium:148757

Review-Url: https://codereview.chromium.org/2386233002
Cr-Commit-Position: refs/heads/master@{#39955}

include/v8.h

@@ -1789,6 +1789,7 @@ class V8_EXPORT ValueSerializer {
    */
   void WriteUint32(uint32_t value);
   void WriteUint64(uint64_t value);
+  void WriteDouble(double value);
   void WriteRawBytes(const void* source, size_t length);
 
  private:
@@ -1875,6 +1876,7 @@ class V8_EXPORT ValueDeserializer {
    */
   V8_WARN_UNUSED_RESULT bool ReadUint32(uint32_t* value);
   V8_WARN_UNUSED_RESULT bool ReadUint64(uint64_t* value);
+  V8_WARN_UNUSED_RESULT bool ReadDouble(double* value);
   V8_WARN_UNUSED_RESULT bool ReadRawBytes(size_t length, const void** data);
 
  private:

src/api.cc

@@ -2975,6 +2975,10 @@ void ValueSerializer::WriteUint64(uint64_t value) {
   private_->serializer.WriteUint64(value);
 }
 
+void ValueSerializer::WriteDouble(double value) {
+  private_->serializer.WriteDouble(value);
+}
+
 void ValueSerializer::WriteRawBytes(const void* source, size_t length) {
   private_->serializer.WriteRawBytes(source, length);
 }
@@ -3099,6 +3103,10 @@ bool ValueDeserializer::ReadUint64(uint64_t* value) {
   return private_->deserializer.ReadUint64(value);
 }
 
+bool ValueDeserializer::ReadDouble(double* value) {
+  return private_->deserializer.ReadDouble(value);
+}
+
 bool ValueDeserializer::ReadRawBytes(size_t length, const void** data) {
   return private_->deserializer.ReadRawBytes(length, data);
 }

src/value-serializer.cc

@@ -903,6 +903,10 @@ bool ValueDeserializer::ReadUint64(uint64_t* value) {
   return ReadVarint<uint64_t>().To(value);
 }
 
+bool ValueDeserializer::ReadDouble(double* value) {
+  return ReadDouble().To(value);
+}
+
 bool ValueDeserializer::ReadRawBytes(size_t length, const void** data) {
   if (length > static_cast<size_t>(end_ - position_)) return false;
   *data = position_;

src/value-serializer.h

@@ -76,6 +76,7 @@ class ValueSerializer {
   void WriteUint32(uint32_t value);
   void WriteUint64(uint64_t value);
   void WriteRawBytes(const void* source, size_t length);
+  void WriteDouble(double value);
 
  private:
   // Writing the wire format.
@@ -84,7 +85,6 @@ class ValueSerializer {
   void WriteVarint(T value);
   template <typename T>
   void WriteZigZag(T value);
-  void WriteDouble(double value);
   void WriteOneByteString(Vector<const uint8_t> chars);
   void WriteTwoByteString(Vector<const uc16> chars);
   uint8_t* ReserveRawBytes(size_t bytes);
@@ -190,6 +190,7 @@ class ValueDeserializer {
    */
   bool ReadUint32(uint32_t* value) WARN_UNUSED_RESULT;
   bool ReadUint64(uint64_t* value) WARN_UNUSED_RESULT;
+  bool ReadDouble(double* value) WARN_UNUSED_RESULT;
   bool ReadRawBytes(size_t length, const void** data) WARN_UNUSED_RESULT;
 
  private:

test/unittests/value-serializer-unittest.cc

@@ -2264,6 +2264,44 @@ TEST_F(ValueSerializerTestWithHostObject, RoundTripUint64) {
       });
 }
 
+TEST_F(ValueSerializerTestWithHostObject, RoundTripDouble) {
+  // The host can serialize data as double.
+  EXPECT_CALL(serializer_delegate_, WriteHostObject(isolate(), _))
+      .WillRepeatedly(Invoke([this](Isolate*, Local<Object> object) {
+        double value = 0;
+        EXPECT_TRUE(object->GetInternalField(0)
+                        ->NumberValue(serialization_context())
+                        .To(&value));
+        WriteExampleHostObjectTag();
+        serializer_->WriteDouble(value);
+        return Just(true);
+      }));
+  EXPECT_CALL(deserializer_delegate_, ReadHostObject(isolate()))
+      .WillRepeatedly(Invoke([this](Isolate*) {
+        EXPECT_TRUE(ReadExampleHostObjectTag());
+        double value = 0;
+        EXPECT_TRUE(deserializer_->ReadDouble(&value));
+        Local<Value> argv[] = {Number::New(isolate(), value)};
+        return NewHostObject(deserialization_context(), arraysize(argv), argv);
+      }));
+  RoundTripTest("new ExampleHostObject(-3.5)", [this](Local<Value> value) {
+    ASSERT_TRUE(value->IsObject());
+    ASSERT_TRUE(Object::Cast(*value)->InternalFieldCount());
+    EXPECT_TRUE(EvaluateScriptForResultBool(
+        "Object.getPrototypeOf(result) === ExampleHostObject.prototype"));
+    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === -3.5"));
+  });
+  RoundTripTest("new ExampleHostObject(NaN)", [this](Local<Value> value) {
+    EXPECT_TRUE(EvaluateScriptForResultBool("Number.isNaN(result.value)"));
+  });
+  RoundTripTest("new ExampleHostObject(Infinity)", [this](Local<Value> value) {
+    EXPECT_TRUE(EvaluateScriptForResultBool("result.value === Infinity"));
+  });
+  RoundTripTest("new ExampleHostObject(-0)", [this](Local<Value> value) {
+    EXPECT_TRUE(EvaluateScriptForResultBool("1/result.value === -Infinity"));
+  });
+}
+
 TEST_F(ValueSerializerTestWithHostObject, RoundTripRawBytes) {
   // The host can serialize arbitrary raw bytes.
   const struct {