1 $$ This is a pump file for generating file templates. Pump is a python 2 $$ script that is part of the Google Test suite of utilities. Description 3 $$ can be found here: 4 $$ 5 $$ http://code.google.com/p/googletest/wiki/PumpManual 6 $$ 7 8 #ifndef GIN_FUNCTION_TEMPLATE_H_ 9 #define GIN_FUNCTION_TEMPLATE_H_ 10 11 $var MAX_ARITY = 6 12 13 // Copyright 2013 The Chromium Authors. All rights reserved. 14 // Use of this source code is governed by a BSD-style license that can be 15 // found in the LICENSE file. 16 17 #include "base/callback.h" 18 #include "base/logging.h" 19 #include "gin/arguments.h" 20 #include "gin/converter.h" 21 #include "gin/gin_export.h" 22 #include "v8/include/v8.h" 23 24 namespace gin { 25 26 class PerIsolateData; 27 28 enum CreateFunctionTemplateFlags { 29 HolderIsFirstArgument = 1 << 0, 30 }; 31 32 namespace internal { 33 34 template<typename T> 35 struct CallbackParamTraits { 36 typedef T LocalType; 37 }; 38 template<typename T> 39 struct CallbackParamTraits<const T&> { 40 typedef T LocalType; 41 }; 42 template<typename T> 43 struct CallbackParamTraits<const T*> { 44 typedef T* LocalType; 45 }; 46 47 48 // CallbackHolder and CallbackHolderBase are used to pass a base::Callback from 49 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to 50 // DispatchToCallback, where it is invoked. 51 52 // This simple base class is used so that we can share a single object template 53 // among every CallbackHolder instance. 54 class GIN_EXPORT CallbackHolderBase { 55 public: 56 v8::Handle<v8::External> GetHandle(v8::Isolate* isolate); 57 58 protected: 59 explicit CallbackHolderBase(v8::Isolate* isolate); 60 virtual ~CallbackHolderBase(); 61 62 private: 63 static void WeakCallback( 64 const v8::WeakCallbackData<v8::External, CallbackHolderBase>& data); 65 66 v8::Persistent<v8::External> v8_ref_; 67 68 DISALLOW_COPY_AND_ASSIGN(CallbackHolderBase); 69 }; 70 71 template<typename Sig> 72 class CallbackHolder : public CallbackHolderBase { 73 public: 74 CallbackHolder(v8::Isolate* isolate, 75 const base::Callback<Sig>& callback, 76 int flags) 77 : CallbackHolderBase(isolate), callback(callback), flags(flags) {} 78 base::Callback<Sig> callback; 79 int flags; 80 private: 81 virtual ~CallbackHolder() {} 82 83 DISALLOW_COPY_AND_ASSIGN(CallbackHolder); 84 }; 85 86 87 // This set of templates invokes a base::Callback, converts the return type to a 88 // JavaScript value, and returns that value to script via the provided 89 // gin::Arguments object. 90 // 91 // In C++, you can declare the function foo(void), but you can't pass a void 92 // expression to foo. As a result, we must specialize the case of Callbacks that 93 // have the void return type. 94 95 $range ARITY 0..MAX_ARITY 96 $for ARITY [[ 97 $var INV_ARITY = MAX_ARITY - ARITY 98 $range ARG 1..INV_ARITY 99 $range VOID INV_ARITY+1..MAX_ARITY 100 101 $if ARITY == 0 [[ 102 template<typename R$for ARG [[, typename P$(ARG) = void]]> 103 struct Invoker { 104 ]] $else [[ 105 template<typename R$for ARG [[, typename P$(ARG)]]> 106 struct Invoker<R$for ARG [[, P$(ARG)]]$for VOID [[, void]]> { 107 ]] 108 109 inline static void Go( 110 Arguments* args, 111 const base::Callback<R($for ARG , [[P$(ARG)]])>& callback$for ARG [[, 112 const P$(ARG)& a$(ARG)]]) { 113 args->Return(callback.Run($for ARG, [[a$(ARG)]])); 114 } 115 }; 116 template<$for ARG , [[typename P$(ARG)]]> 117 struct Invoker<void$for ARG [[, P$(ARG)]]$for VOID [[, void]]> { 118 inline static void Go( 119 Arguments* args, 120 const base::Callback<void($for ARG , [[P$(ARG)]])>& callback$for ARG [[, 121 const P$(ARG)& a$(ARG)]]) { 122 callback.Run($for ARG, [[a$(ARG)]]); 123 } 124 }; 125 126 127 ]] 128 129 template<typename T> 130 bool GetNextArgument(Arguments* args, int create_flags, bool is_first, 131 T* result) { 132 if (is_first && (create_flags & HolderIsFirstArgument) != 0) { 133 return args->GetHolder(result); 134 } else { 135 return args->GetNext(result); 136 } 137 } 138 139 // For advanced use cases, we allow callers to request the unparsed Arguments 140 // object and poke around in it directly. 141 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first, 142 Arguments* result) { 143 *result = *args; 144 return true; 145 } 146 inline bool GetNextArgument(Arguments* args, int create_flags, bool is_first, 147 Arguments** result) { 148 *result = args; 149 return true; 150 } 151 152 // It's common for clients to just need the isolate, so we make that easy. 153 inline bool GetNextArgument(Arguments* args, int create_flags, 154 bool is_first, v8::Isolate** result) { 155 *result = args->isolate(); 156 return true; 157 } 158 159 160 // DispatchToCallback converts all the JavaScript arguments to C++ types and 161 // invokes the base::Callback. 162 template<typename Sig> 163 struct Dispatcher { 164 }; 165 166 $range ARITY 0..MAX_ARITY 167 $for ARITY [[ 168 $range ARG 1..ARITY 169 170 template<typename R$for ARG [[, typename P$(ARG)]]> 171 struct Dispatcher<R($for ARG , [[P$(ARG)]])> { 172 static void DispatchToCallback( 173 const v8::FunctionCallbackInfo<v8::Value>& info) { 174 Arguments args(info); 175 v8::Handle<v8::External> v8_holder; 176 CHECK(args.GetData(&v8_holder)); 177 CallbackHolderBase* holder_base = reinterpret_cast<CallbackHolderBase*>( 178 v8_holder->Value()); 179 180 typedef CallbackHolder<R($for ARG , [[P$(ARG)]])> HolderT; 181 HolderT* holder = static_cast<HolderT*>(holder_base); 182 183 $if ARITY != 0 [[ 184 185 186 $for ARG [[ typename CallbackParamTraits<P$(ARG)>::LocalType a$(ARG); 187 188 ]] 189 if ($for ARG || 190 [[!GetNextArgument(&args, holder->flags, $if ARG == 1 [[true]] $else [[false]], &a$(ARG))]]) { 191 args.ThrowError(); 192 return; 193 } 194 195 ]] 196 197 Invoker<R$for ARG [[, P$(ARG)]]>::Go(&args, holder->callback$for ARG [[, a$(ARG)]]); 198 } 199 }; 200 201 ]] 202 203 } // namespace internal 204 205 206 // CreateFunctionTemplate creates a v8::FunctionTemplate that will create 207 // JavaScript functions that execute a provided C++ function or base::Callback. 208 // JavaScript arguments are automatically converted via gin::Converter, as is 209 // the return value of the C++ function, if any. 210 template<typename Sig> 211 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate( 212 v8::Isolate* isolate, const base::Callback<Sig> callback, 213 int callback_flags = 0) { 214 typedef internal::CallbackHolder<Sig> HolderT; 215 HolderT* holder = new HolderT(isolate, callback, callback_flags); 216 217 return v8::FunctionTemplate::New( 218 isolate, 219 &internal::Dispatcher<Sig>::DispatchToCallback, 220 ConvertToV8<v8::Handle<v8::External> >(isolate, 221 holder->GetHandle(isolate))); 222 } 223 224 // CreateFunctionHandler installs a CallAsFunction handler on the given 225 // object template that forwards to a provided C++ function or base::Callback. 226 template<typename Sig> 227 void CreateFunctionHandler(v8::Isolate* isolate, 228 v8::Local<v8::ObjectTemplate> tmpl, 229 const base::Callback<Sig> callback, 230 int callback_flags = 0) { 231 typedef internal::CallbackHolder<Sig> HolderT; 232 HolderT* holder = new HolderT(isolate, callback, callback_flags); 233 tmpl->SetCallAsFunctionHandler(&internal::Dispatcher<Sig>::DispatchToCallback, 234 ConvertToV8<v8::Handle<v8::External> >( 235 isolate, holder->GetHandle(isolate))); 236 } 237 238 } // namespace gin 239 240 #endif // GIN_FUNCTION_TEMPLATE_H_ 241
