IDL: Drop value conversion (V8 -> C++) macros from generated code

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 78 matching lines @@
     const String& message() const { return m_message; }
 
     bool throwIfNeeded()
     {
         if (!hadException())
             return false;
         throwException();
         return true;
     }
 
+    void throwException();

[yhirano, 2015/02/24 03:51:24]

Can you tell me why you want this function in addition to throwIfNeeded?
I don't like this function name, because it is very confusing (what
throwTypeError does is very different from what throwException does). I think
this function should not be public.

[Jens Widell, 2015/02/24 07:31:43]

I use it in a situation where I know an exception was thrown, in the "stored in
this object" sense, and just need it thrown in the "throw in V8" sense. Using
throwIfNeeded() would have worked, but would have been somewhat "dishonest"
since there's no question that throwing is needed.

I agree that the name of this function is unfortunate. But the same problem
exists in "throwIfNeeded", I think, since the problem is that "throw" is
overloaded with two different meanings, and "throwIfNeeded" and "throwException"
use it the same way.

The best naming scheme I can think of would be to change "throwTypeError" (and
friends) to "scheduleTypeError", leaving these the only "throw"ing functions.

Personally, I'm not convinced we must change the naming, or that this function
must be private. It's name may be somewhat misleading, but it's fairly obvious
from its signature (no arguments) that it can't be used to "schedule" a new
exception. (It also asserts if you try to use it that way.)

[Jens Widell, 2015/02/24 15:34:56]

I've reverted this change, as it wasn't really required.

+
     // This method clears out the exception which |this| has.
     ScriptPromise reject(ScriptState*);
 
     Context context() const { return m_context; }
     const char* propertyName() const { return m_propertyName; }
     const char* interfaceName() const { return m_interfaceName; }
 
     void rethrowV8Exception(v8::Handle<v8::Value> value)
     {
         setException(value);
     }
 
 #if ENABLE(ASSERT)
     OnStackObjectChecker& onStackObjectChecker() { return m_onStackObjectChecker; }
 #endif
 
 protected:
     ExceptionCode m_code;
     Context m_context;
     String m_message;
     const char* m_propertyName;
     const char* m_interfaceName;
 
 private:
     void setException(v8::Handle<v8::Value>);
-    void throwException();
 
     String addExceptionContext(const String&) const;
 
     ScopedPersistent<v8::Value> m_exception;
     v8::Handle<v8::Object> m_creationContext;
     v8::Isolate* m_isolate;
 #if ENABLE(ASSERT)
     OnStackObjectChecker m_onStackObjectChecker;
 #endif
 };
@@ skipping 14 matching lines @@
     TrackExceptionState(): ExceptionState(ExceptionState::UnknownContext, 0, 0, v8::Handle<v8::Object>(), v8::Isolate::GetCurrent()) { }
     virtual void throwDOMException(const ExceptionCode&, const String& message) override;
     virtual void throwTypeError(const String& message = String()) override;
     virtual void throwSecurityError(const String& sanitizedMessage, const String& unsanitizedMessage = String()) override;
     virtual void throwRangeError(const String& message) override;
 };
 
 } // namespace blink
 
 #endif // ExceptionState_h