Follow object map transitions when deserializing object properties.

test/unittests/value-serializer-unittest.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/value-serializer.h"
 
 #include <algorithm>
 #include <string>
 
 #include "include/v8.h"
@@ skipping 32 matching lines @@
   }
 
   // Variant for the common case where a script is used to build the original
   // value.
   template <typename OutputFunctor>
   void RoundTripTest(const char* source, const OutputFunctor& output_functor) {
     RoundTripTest([this, source]() { return EvaluateScriptForInput(source); },
                   output_functor);
   }
 
+  // Variant which uses JSON.parse/stringify to check the result.
+  void RoundTripJSON(const char* source) {
+    RoundTripTest(
+        [this, source]() {
+          return JSON::Parse(serialization_context_, StringFromUtf8(source))
+              .ToLocalChecked();
+        },
+        [this, source](Local<Value> value) {
+          ASSERT_TRUE(value->IsObject());
+          EXPECT_EQ(source, Utf8Value(JSON::Stringify(deserialization_context_,
+                                                      value.As<Object>())
+                                          .ToLocalChecked()));
+        });
+  }
+
   Maybe<std::vector<uint8_t>> DoEncode(Local<Value> value) {
     Local<Context> context = serialization_context();
     ValueSerializer serializer(isolate());
     BeforeEncode(&serializer);
     serializer.WriteHeader();
     if (!serializer.WriteValue(context, value).FromMaybe(false)) {
       return Nothing<std::vector<uint8_t>>();
     }
     return Just(serializer.ReleaseBuffer());
   }
@@ skipping 586 matching lines @@
   // If an exception is thrown by script, encoding must fail and the exception
   // must be thrown.
   InvalidEncodeTest("({ get a() { throw new Error('sentinel'); } })",
                     [](Local<Message> message) {
                       ASSERT_FALSE(message.IsEmpty());
                       EXPECT_NE(std::string::npos,
                                 Utf8Value(message->Get()).find("sentinel"));
                     });
 }
 
+TEST_F(ValueSerializerTest, RoundTripDictionaryObjectForTransitions) {
+  // A case which should run on the fast path, and should reach all of the
+  // different cases:
+  // - expected transition matched
+  // - expected transition failed to match
+  // - transition found (of multiple possible)
+  // - no known transition

[Camillo Bruni, 2016/09/14 16:26:20]

nit: can you update the order of the comment, so it matches the test?

1. xyz (no known transition as this is the first time we create this kind of
object)
2. xyz (full simple transition matches)
3. xyw (transition partially matches, w is not found, causing fallback)
4. xyz (transition matches, with xy being simple transition, and w a full
transition)
5. xyw (same)

[jbroman, 2016/09/14 19:07:16]

Done.

+  RoundTripJSON(
+      "[{\"x\":1,\"y\":2,\"z\":3},{\"x\":4,\"y\":5,\"z\":6},{\"x\":5,\"y\":6,"
+      "\"w\":7},{\"x\":6,\"y\":7,\"z\":8},{\"x\":0,\"y\":0,\"w\":0}]");

[Camillo Bruni, 2016/09/14 16:26:20]

late question: single quotes doesn't work for the properties here?
nit: could you force newlines whenever a new object starts? This makes reading
this way easier.

There are two more cases I would like to have a test for, just in case :)
nit: can you test the path of adding more properties after a complex transition
succeeded (xywz)
int: can you test the path of adding more properties after a complex transition
wasn't found (zykz)

[jbroman, 2016/09/14 19:07:16]

This uses JSON::Parse/Stringify to compare the object before/after doing a
serialization round trip (because there aren't many easy ways to do a  deep
comparison), so this needs to match the JSON output verbatim, and that means
double quotes.
But I can wrap more nicely than clang-format's default, and I've done that.
Done.

+  // A slightly simpler case that uses two-byte strings.
+  RoundTripJSON(
+      "[{\"\xF0\x9F\x91\x8A\":1,\"\xF0\x9F\x91\x8B\":2},{\"\xF0\x9F\x91\x8A\":"
+      "3,\"\xF0\x9F\x91\x8C\":4},{\"\xF0\x9F\x91\x8A\":5,\"\xF0\x9F\x91\x9B\":"
+      "6}]");
+}
+
 TEST_F(ValueSerializerTest, DecodeDictionaryObjectVersion0) {
   // Empty object.
   DecodeTestForVersion0(
       {0x7b, 0x00},
       [this](Local<Value> value) {
         ASSERT_TRUE(value->IsObject());
         EXPECT_TRUE(EvaluateScriptForResultBool(
             "Object.getPrototypeOf(result) === Object.prototype"));
         EXPECT_TRUE(EvaluateScriptForResultBool(
             "Object.getOwnPropertyNames(result).length === 0"));
@@ skipping 1350 matching lines @@
 }
 
 TEST_F(ValueSerializerTestWithSharedArrayBufferTransfer,
        SharedArrayBufferMustBeTransferred) {
   // A SharedArrayBuffer which was not marked for transfer should fail encoding.
   InvalidEncodeTest("new SharedArrayBuffer(32)");
 }
 
 }  // namespace
 }  // namespace v8