Rename V8TRYCATCH_* macros in v8/V8BindingMacros.h

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 15 matching lines @@
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef V8BindingMacros_h
 #define V8BindingMacros_h
 
 namespace WebCore {
 
+// Naming scheme:
+// COMMAND[_VOID][_ARG]...

[haraken, 2014/04/11 02:33:20]

COMMAND[_RETURNTYPE][_ARGUMENTTYPE]... ?

Currently you are using "V8TRYCATCH" and "V8STRINGRESOURCE" for COMMAND, but
"TONATIVE" and "TOSTRING" might be clearer.

These macros are for converting V8 values to native C++ values with a TryCatch
block.

[Nils Barth (inactive), 2014/04/11 03:00:56]

How about
TONATIVE[_TYPE][_ARGUMENTTYPE]...
That way we get
TONATIVE_VOID*
TONATIVE_BOOL*
TONATIVE_STRING*
...etc.?

[haraken, 2014/04/11 03:28:59]

Actually, TONATIVE_BOOL and TONATIVE_STRING are different.

- TONATIVE_BOOL means "please convert this value to some type and return
true/false depending on whether the conversion was a success or not".

- TONATIVE_STRING means "please convert this value to a string".

So I'd prefer using [TONATIVE|TOSTRING]_[RETURNTYPE]_[ARGS].

+
 #define V8TRYCATCH(type, var, value)     \

[haraken, 2014/04/11 02:33:20]

V8TRYCATCH_EXCEPTION ?

     type var;                            \
     {                                    \
         v8::TryCatch block;              \
         var = (value);                   \
         if (UNLIKELY(block.HasCaught())) \
             return block.ReThrow();      \
     }
 
+#define V8TRYCATCH_VOID(type, var, value)  \
+    type var;                              \
+    {                                      \
+        v8::TryCatch block;                \
+        var = (value);                     \
+        if (UNLIKELY(block.HasCaught())) { \
+            block.ReThrow();               \
+            return;                        \
+        }                                  \
+    }
+
 #define V8TRYCATCH_RETURN(type, var, value, retVal) \

[haraken, 2014/04/11 02:33:20]

V8TRYCATCH_BOOL ?

     type var;                                       \
     {                                               \
         v8::TryCatch block;                         \
         var = (value);                              \
         if (UNLIKELY(block.HasCaught())) {          \
             block.ReThrow();                        \
             return retVal;                          \
         }                                           \
     }
 
+#define V8TRYCATCH_VOID_EXCEPTION(type, var, value, exceptionState) \

[haraken, 2014/04/11 02:33:20]

V8TRYCATCH_VOID_EXCEPTIONSTATE ?

+    type var;                                                       \
+    {                                                               \
+        v8::TryCatch block;                                         \
+        var = (value);                                              \
+        if (UNLIKELY(block.HasCaught()))                            \
+            exceptionState.rethrowV8Exception(block.Exception());   \
+        if (UNLIKELY(exceptionState.throwIfNeeded()))               \
+            return;                                                 \
+    }
+
 #define V8TRYCATCH_EXCEPTION_RETURN(type, var, value, exceptionState, retVal) \

[haraken, 2014/04/11 02:33:20]

V8TRYCATCH_BOOL_EXCEPTIONSTATE ?

     type var;                                                                 \
     {                                                                         \
         v8::TryCatch block;                                                   \
         var = (value);                                                        \
         if (UNLIKELY(block.HasCaught()))                                      \
             exceptionState.rethrowV8Exception(block.Exception());             \
         if (UNLIKELY(exceptionState.throwIfNeeded()))                         \
             return retVal;                                                    \
     }
 
-#define V8TRYCATCH_VOID(type, var, value)  \
-    type var;                              \
-    {                                      \
-        v8::TryCatch block;                \
-        var = (value);                     \
-        if (UNLIKELY(block.HasCaught())) { \
-            block.ReThrow();               \
-            return;                        \
-        }                                  \
-    }
+#define V8STRINGRESOURCE_PREPARE_VOID(type, var, value) \
+    type var(value);                                    \

[haraken, 2014/04/11 02:33:20]

You can drop the |type| parameter, because |type| should always be
V8StringResource.

[Nils Barth (inactive), 2014/04/11 03:00:56]

V8StringResource<> is a class template, and is instantiated by giving args,
so the type does differ.

We could reduce this to the template arguments, if any, but that makes the
binding generator code more complicated (b/c it's no longer specifying the
full type), and makes these macros less uniform.
(It also gives the C preprocessor some indigestion, due to the <> tokens
and blank arguments. It's doable, but ugly.)

So I think it's simplest as it is.

[haraken, 2014/04/11 03:28:59]

Makes sense.

[Nils Barth (inactive), 2014/04/11 06:01:38]

Anyway, added a comment about usage.

+    if (UNLIKELY(!var.prepare()))                       \
+        return;
 
-#define V8TRYCATCH_EXCEPTION_VOID(type, var, value, exceptionState) \
-    type var;                                                       \
-    {                                                               \
-        v8::TryCatch block;                                         \
-        var = (value);                                              \
-        if (UNLIKELY(block.HasCaught()))                            \
-            exceptionState.rethrowV8Exception(block.Exception());   \
-        if (UNLIKELY(exceptionState.throwIfNeeded()))               \
-            return;                                                 \
-    }
-
-#define V8TRYCATCH_FOR_V8STRINGRESOURCE_RETURN(type, var, value, retVal) \
-    type var(value);                                                     \
-    if (UNLIKELY(!var.prepare()))                                        \
+#define V8STRINGRESOURCE_PREPARE_RETURN(type, var, value, retVal) \
+    type var(value);                                              \

[haraken, 2014/04/11 02:33:20]

Ditto.

+    if (UNLIKELY(!var.prepare()))                                 \
         return retVal;
 
-#define V8TRYCATCH_FOR_V8STRINGRESOURCE_VOID(type, var, value) \
-    type var(value);                                           \
-    if (UNLIKELY(!var.prepare()))                              \
-        return;
-
 } // namespace WebCore
 
 #endif // V8BindingMacros_h