Rethrow exception when swallowing it is not intended.

Source/bindings/v8/V8BindingMacros.h

 /*
  * Copyright (C) 2010 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 53 matching lines @@
     {                                              \
         v8::TryCatch block;                        \
         var = (value);                             \
         if (UNLIKELY(block.HasCaught())) {         \
             block.ReThrow();                       \
             return retVal;                         \
         }                                          \
     }
 
 #define TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(var, value, exceptionState) \
-    var = (value);                                                       \
-    if (UNLIKELY(block.HasCaught()))                                     \
-        exceptionState.rethrowV8Exception(block.Exception());            \
-    if (UNLIKELY(exceptionState.throwIfNeeded()))                        \
+    var = (value);                                                        \
+    if (UNLIKELY(block.HasCaught())) {                                    \
+        exceptionState.rethrowV8Exception(block.Exception());             \

[Jens Widell, 2014/06/16 11:56:39]

Given current usage of this macro and the one below (here, in
V8ElementCustom.cpp and in generated bindings code), I'm pretty sure it's
pointless to call rethrowV8Exception() here now, since 'block' will re-throw the
caught exception on its own, and 'exceptionState' is a local that goes out of
scope when you return.

So I reckon this could be

  if (UNLIKELY(block.HasCaught() || exceptionState.throwIfNeeded()))
    return;

instead.

And if these macros were supposed to be useful in general code, I'd assume the
user would expect the resulting exception to be in 'exceptionState' only, and
not already have been rethrown via the V8 API.

But I'm of course quite new to this code. :-)

[yhirano, 2014/06/17 11:10:02]

Done.

+        return;                                                           \
+    }                                                                     \
+    if (UNLIKELY(exceptionState.throwIfNeeded()))                         \
         return;
 
-#define TONATIVE_VOID_EXCEPTIONSTATE(type, var, value, exceptionState)    \
-    type var;                                                             \
-    {                                                                     \
-        v8::TryCatch block;                                               \
+#define TONATIVE_VOID_EXCEPTIONSTATE(type, var, value, exceptionState)     \
+    type var;                                                              \
+    {                                                                      \
+        v8::TryCatch block;                                                \
+        V8RethrowTryCatchScope rethrow(block);                             \
         TONATIVE_VOID_EXCEPTIONSTATE_INTERNAL(var, value, exceptionState); \
     }
 
 #define TONATIVE_DEFAULT_EXCEPTIONSTATE(type, var, value, exceptionState, retVal) \
-    type var;                                                                 \
-    {                                                                         \
-        v8::TryCatch block;                                                   \
-        var = (value);                                                        \
-        if (UNLIKELY(block.HasCaught()))                                      \
-            exceptionState.rethrowV8Exception(block.Exception());             \
-        if (UNLIKELY(exceptionState.throwIfNeeded()))                         \
-            return retVal;                                                    \
+    type var;                                                                     \
+    {                                                                             \
+        v8::TryCatch block;                                                       \
+        V8RethrowTryCatchScope rethrow(block);                                    \
+        var = (value);                                                            \
+        if (UNLIKELY(block.HasCaught())) {                                        \
+            exceptionState.rethrowV8Exception(block.Exception());                 \
+            return retVal;                                                        \
+        }                                                                         \
+        if (UNLIKELY(exceptionState.throwIfNeeded()))                             \
+            return retVal;                                                        \
     }
 
 // type is an instance of class template V8StringResource<>,
 // but Mode argument varies; using type (not Mode) for consistency
 // with other macros and ease of code generation
 #define TOSTRING_VOID(type, var, value) \
     type var(value);                    \
     if (UNLIKELY(!var.prepare()))       \
         return;
 
 #define TOSTRING_VOID_INTERNAL(var, value) \
     var = (value);                         \
     if (UNLIKELY(!var.prepare()))          \
         return;
 
 #define TOSTRING_DEFAULT(type, var, value, retVal) \
     type var(value);                               \
     if (UNLIKELY(!var.prepare()))                  \
         return retVal;
 
 } // namespace WebCore
 
 #endif // V8BindingMacros_h