Implement v8::ValueSerializer::Delegate to throw DOMException for DataCloneError.

third_party/WebKit/Source/bindings/core/v8/ExceptionState.h

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 namespace blink {
 
 typedef int ExceptionCode;
 class ScriptPromiseResolver;
 class ScriptState;
 
 // ExceptionState is a scope-like class and provides a way to throw an exception
 // with an option to cancel it.  An exception message may be auto-generated.
 // You can convert an exception to a reject promise.
 class CORE_EXPORT ExceptionState {
-    STACK_ALLOCATED();

[jbroman, 2016/09/06 20:39:27]

This change was made because the blink-gc plugin won't permit holding a pointer
to ExceptionState in a class that implements a non-GC interface. This object
doesn't hold pointers to Oilpan objects anyhow, so it doesn't need this.

[haraken, 2016/09/07 00:27:54]

Hmm, I'd like to keep the STACK_ALLOCATED. STACK_ALLOCATED is not only for
oilpan but also for asserting that the class should be used on the stack
(otherwise it's likely to be a bug).

Any idea to restructure the class design around V8ScriptValueSerializer and keep
the STACK_ALLOCATED as is?

[jbroman, 2016/09/07 01:03:34]

Isn't that what DISALLOW_NEW is for? If not, what is the distinction between
STACK_ALLOCATED and DISALLOW_NEW?

I don't think it's very clear whether STACK_ALLOCATED is supposed to mean "this
should be on the stack" or "this is an Oilpan object that only exists on the
stack".

If it is supposed to be the former, then I don't think the restriction that it
only have STACK_ALLOCATED base classes makes sense, because it prevents any pure
interface base class. (And I don't understand the restriction; shouldn't that
restriction be "no base class should be GarbageCollected"?)

V8ScriptValueSerializer could be split into two classes to work around this, but
I'd rather not complicate the code to satisfy blink_gc_plugin, especially when
there's nothing Oilpan-related going on here.

[jbroman, 2016/09/07 01:13:16]

Also, the comment says:

// Classes that contain references to garbage-collected objects but aren't
// themselves garbaged allocated, have some extra macros available which
// allows their use to be restricted to cases where the garbage collector
// is able to discover their references.

So if this is intended also for use on classes that don't use GC objects,
maybe the comment _and_ blink_gc_plugin should be revised?

     WTF_MAKE_NONCOPYABLE(ExceptionState);
 public:
     enum ContextType {
         ConstructionContext,
         ExecutionContext,
         DeletionContext,
         GetterContext,
         SetterContext,
         EnumerationContext,
         QueryContext,
@@ skipping 118 matching lines @@
     void throwDOMException(const ExceptionCode&, const String& message) override;
     void throwTypeError(const String& message) override;
     void throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage) override;
     void throwRangeError(const String& message) override;
     void rethrowV8Exception(v8::Local<v8::Value>) override;
 };
 
 } // namespace blink
 
 #endif // ExceptionState_h