Throw exceptions for errors in v8::ValueSerializer.

src/value-serializer.h

 // 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.
 
 #ifndef V8_VALUE_SERIALIZER_H_
 #define V8_VALUE_SERIALIZER_H_
 
 #include <cstdint>
 #include <vector>
 
 #include "include/v8.h"
 #include "src/base/compiler-specific.h"
 #include "src/base/macros.h"
 #include "src/identity-map.h"
+#include "src/messages.h"
 #include "src/vector.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 class HeapNumber;
 class Isolate;
 class JSArrayBuffer;
 class JSArrayBufferView;
 class JSDate;
 class JSMap;
 class JSRegExp;
 class JSSet;
 class JSValue;
 class Object;
 class Oddball;
 class Smi;
 
 enum class SerializationTag : uint8_t;
 
 /**
  * Writes V8 objects in a binary format that allows the objects to be cloned
  * according to the HTML structured clone algorithm.
  *
  * Format is based on Blink's previous serialization logic.
  */
 class ValueSerializer {
  public:
-  explicit ValueSerializer(Isolate* isolate);
+  ValueSerializer(Isolate* isolate, v8::ValueSerializer::Delegate* delegate);
   ~ValueSerializer();
 
   /*
    * Writes out a header, which includes the format version.
    */
   void WriteHeader();
 
   /*
    * Serializes a V8 object into the buffer.
    */
@@ skipping 43 matching lines @@
   Maybe<bool> WriteJSArrayBufferView(JSArrayBufferView* array_buffer);
 
   /*
    * Reads the specified keys from the object and writes key-value pairs to the
    * buffer. Returns the number of keys actually written, which may be smaller
    * if some keys are not own properties when accessed.
    */
   Maybe<uint32_t> WriteJSObjectProperties(
       Handle<JSObject> object, Handle<FixedArray> keys) WARN_UNUSED_RESULT;
 
+  /*
+   * Asks the delegate to throw handle an error that occurred during data

[Jakob Kummerow, 2016/09/02 10:20:28]

nit: s/throw handle/handle/

[jbroman, 2016/09/02 14:51:09]

Done.

+   * cloning, by throwing an exception appropriate for the host.
+   */
+  void ThrowDataCloneError(MessageTemplate::Template template_index);
+  V8_NOINLINE void ThrowDataCloneError(MessageTemplate::Template template_index,
+                                       Handle<Object> arg0);
+
   Isolate* const isolate_;
+  v8::ValueSerializer::Delegate* const delegate_;
   std::vector<uint8_t> buffer_;
   Zone zone_;
 
   // To avoid extra lookups in the identity map, ID+1 is actually stored in the
   // map (checking if the used identity is zero is the fast way of checking if
   // the entry is new).
   IdentityMap<uint32_t> id_map_;
   uint32_t next_id_ = 0;
 
   // A similar map, for transferred array buffers.
@@ skipping 101 matching lines @@
   Handle<SeededNumberDictionary> id_map_;
   MaybeHandle<SeededNumberDictionary> array_buffer_transfer_map_;
 
   DISALLOW_COPY_AND_ASSIGN(ValueDeserializer);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_VALUE_SERIALIZER_H_