bindings: Use V8 MaybeLocal APIs in V8DeviceMotionEventCustom

Source/bindings/core/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 59 matching lines @@
 #define TOSTRING_VOID(type, var, value) \
     type var(value);                    \
     if (UNLIKELY(!var.prepare()))       \
         return;
 
 #define TOSTRING_DEFAULT(type, var, value, retVal) \
     type var(value);                               \
     if (UNLIKELY(!var.prepare()))                  \
         return retVal;
 
+// Use this macro to call V8 APIs which return MaybeLocal<T>.
+#define CALL_V8_WITH_CHECK_MAYBELOCAL_DEFAULT(type, outVariable, callExpression, returnValue) \

[Jens Widell, 2015/03/04 10:33:05]

This macro reminds me quite a lot about the growing set of macros we recently
removed from this file.

We'll need different macro variants in much the same cases, I think:

- Should an ExceptionState be used?

- Should a local variable be declared or should a previously declared one be
assigned?

- Should a value be returned?

And at the end of the day, the macro doesn't do a lot. (And macros that do a lot
should be functions anyway.)

Are we worried about having ToLocal() calls spelled out in the code?

Does a macro named CALL_V8_WITH_CHECK_MAYBELOCAL_DEFAULT() make the code more
obvious and easy to read? :-)

+    v8::Local<type> outVariable;                                                              \
+    {                                                                                         \
+        v8::TryCatch block;                                                                   \

[Jens Widell, 2015/03/04 10:21:45]

This TryCatch serves no purpose. Exceptions are propagated by default so there's
no need to catch and rethrow them if you're not interested in seeing the
exception, and don't mean to use block.HasCaught() to detect failure in the
first place.

+        if (!(callExpression).ToLocal(&outVariable)) {                                        \

[bashi, 2015/03/04 10:12:45]

Dropped outVariable.IsEmpty() check because when this condition is true,
outVariable.IsEmpty() is always true.

+            if (block.HasCaught())                                                            \
+                block.ReThrow();                                                              \
+            return returnValue;                                                               \
+        }                                                                                     \
+    }
+
 } // namespace blink
 
 #endif // V8BindingMacros_h