Move utilities for V8 extras functions into V8Binding.h

third_party/WebKit/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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * 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
 
+#include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/V8ScriptRunner.h"

[haraken, 2016/01/19 21:49:48]

Hmm, V8BindingMacros.h is intended to be a collection of simple macros that
don't need to include other binding headers. (I was a bit surprised that
including these headers doesn't cause #include cycles :-)

Given that v8CallExtra is complicated enough, would you move it to V8Binding.h?

+#include <v8.h>
+
 namespace blink {
 
 // 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;
 
@@ skipping 52 matching lines @@
 {
     return maybe.FromJust();
 }
 
 template <typename T>
 inline v8::Local<T> v8CallOrCrash(v8::MaybeLocal<T> maybeLocal)
 {
     return maybeLocal.ToLocalChecked();
 }
 
+// These are utiltiies for calling functions added to the V8 extras binding object.
+
+inline v8::MaybeLocal<v8::Value> v8CallExtraHelper(ScriptState* scriptState, const char* name, size_t numArgs, v8::Local<v8::Value>* args)
+{
+    v8::Isolate* isolate = scriptState->isolate();
+    ExecutionContext* ec = scriptState->executionContext();
+    v8::Local<v8::Value> undefined = v8::Undefined(isolate);
+    v8::Local<v8::Value> functionValue = scriptState->getFromExtrasExports(name).v8Value();
+    v8::Local<v8::Function> function = functionValue.As<v8::Function>();
+    return V8ScriptRunner::callFunction(function, ec, undefined, numArgs, args, isolate);
+}
+
+template <size_t N>
+v8::MaybeLocal<v8::Value> v8CallExtra(ScriptState* scriptState, const char* name, v8::Local<v8::Value>(&args)[N])
+{
+    return v8CallExtraHelper(scriptState, name, N, args);
+}
+
+template <size_t N>
+v8::Local<v8::Value> v8CallExtraOrCrash(ScriptState* scriptState, const char* name, v8::Local<v8::Value>(&args)[N])
+{
+    return v8CallOrCrash(v8CallExtraHelper(scriptState, name, N, args));
+}
+
 // The last "else" is to avoid dangling else problem.
 #define V8_CALL(outVariable, handle, methodCall, failureExpression)                \
     if (handle.IsEmpty() || !v8Call(handle->methodCall, outVariable)) { \
         failureExpression;                                                         \
     } else
 
 } // namespace blink
 
 #endif // V8BindingMacros_h